summaryrefslogtreecommitdiff
path: root/bench/example.cpp
diff options
context:
space:
mode:
authormurphy <murphy@rubychan.de>2005-10-29 14:49:23 +0000
committermurphy <murphy@rubychan.de>2005-10-29 14:49:23 +0000
commit382685e66f662d8bfb760099ec5e394f15db0d3c (patch)
tree56c395136b35fa36a0589ecb04984b7d3a7b0eff /bench/example.cpp
parent84199b89843d0eca9a85b66dbeae9fd10fdc7d63 (diff)
downloadcoderay-382685e66f662d8bfb760099ec5e394f15db0d3c.tar.gz
Added the good old benchmark suite to the repository.
Diffstat (limited to 'bench/example.cpp')
-rw-r--r--bench/example.cpp13544
1 files changed, 13544 insertions, 0 deletions
diff --git a/bench/example.cpp b/bench/example.cpp
new file mode 100644
index 0000000..ba9cf72
--- /dev/null
+++ b/bench/example.cpp
@@ -0,0 +1,13544 @@
+/***************************************************************************
+ ansigenerator.cpp - description
+ -------------------
+ begin : Jul 5 2004
+ copyright : (C) 2004 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 "ansigenerator.h"
+
+using namespace std;
+
+namespace highlight {
+
+
+string AnsiGenerator::getOpenTag(const string&font,
+ const string&fgCol, const string&bgCol) {
+ ostringstream s;
+ s << "\033["<<font;
+ if (!fgCol.empty())
+ s<<";"<<fgCol;
+ if (!bgCol.empty())
+ s<<";"<<bgCol;
+ s << "m";
+ return s.str();
+}
+
+
+AnsiGenerator::AnsiGenerator(const string &colourTheme)
+ : CodeGenerator(colourTheme) {
+ styleTagOpen.push_back("");
+ styleTagOpen.push_back(getOpenTag("00", "31")); //str
+ styleTagOpen.push_back(getOpenTag("00", "34"));//number
+ styleTagOpen.push_back(getOpenTag("00", "34"));//sl comment
+ styleTagOpen.push_back(getOpenTag("00", "34"));//ml comment
+ styleTagOpen.push_back(getOpenTag("00", "35"));//escapeChar
+ styleTagOpen.push_back(getOpenTag("00", "35"));//directive
+ styleTagOpen.push_back(getOpenTag("01", "31"));//directive string
+ styleTagOpen.push_back(getOpenTag("00", "30"));//linenum
+ styleTagOpen.push_back(getOpenTag("01", "00"));//symbol
+
+ styleTagClose.push_back("");
+ for (int i=1;i<NUMBER_BUILTIN_STYLES; i++) {
+ styleTagClose.push_back("\033[m");
+ }
+ newLineTag = "\n";
+ spacer = " ";
+}
+
+AnsiGenerator::AnsiGenerator() {}
+AnsiGenerator::~AnsiGenerator() {}
+
+string AnsiGenerator::getHeader(const string & title) {
+ return string();
+}
+
+void AnsiGenerator::printBody() {
+ processRootState();
+}
+
+string AnsiGenerator::getFooter() {
+ return string();
+}
+
+string AnsiGenerator::maskCharacter(unsigned char c) {
+ string m;
+ m+=c;
+ return m;
+}
+
+string AnsiGenerator::getMatchingOpenTag(unsigned int styleID) {
+ return (styleID)?getOpenTag("01", "32", ""):getOpenTag("00", "33");
+}
+
+string AnsiGenerator::getMatchingCloseTag(unsigned int styleID) {
+ return "\033[m";
+}
+
+}
+/***************************************************************************
+ ansicode.h - description
+ -------------------
+ begin : Jul 5 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 ANSIGENERATOR_H
+#define ANSIGENERATOR_H
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+
+#include "codegenerator.h"
+#include "charcodes.h"
+#include "version.h"
+
+namespace highlight {
+
+/**
+ \brief This class generates ANSI escape sequences.
+
+ 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 AnsiGenerator : public highlight::CodeGenerator
+ {
+ public:
+
+ /** Constructor
+ \param colourTheme Name of Colour theme to use
+ */
+ AnsiGenerator( const string &colourTheme);
+ AnsiGenerator();
+ ~AnsiGenerator();
+
+ /** 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 );
+
+
+ /** gibt ANSI-"Tags" zurueck (Farbindex+bold+kursiv)*/
+ string getOpenTag(const string&font,
+ const string&fgCol, const string&bgCol="");
+
+
+
+ string getMatchingOpenTag(unsigned int styleID);
+ string getMatchingCloseTag(unsigned int styleID);
+ };
+
+}
+#endif
+/*
+ * Copyright (c) 1998,1999,2000,2001,2002 Tal Davidson. All rights reserved.
+ *
+ * ASBeautifier.cpp
+ * 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.
+ *
+ * Patches:
+ * 18 March 1999 - Brian Rampel -
+ * Fixed inverse insertion of spaces vs. tabs when in -t mode.
+ * 08 may 2004
+ * applied ASBeautifier.cpp.BITFIELD.patch.bz2
+ */
+
+#include "compiler_defines.h"
+#include "ASBeautifier.h"
+
+#include <vector>
+#include <string>
+#include <cctype>
+#include <algorithm>
+#include <iostream>
+
+
+#define INIT_CONTAINER(container, value) {if ( (container) != NULL ) delete (container); (container) = (value); }
+#define DELETE_CONTAINER(container) {if ( (container) != NULL ) delete (container) ; }
+
+#ifdef USES_NAMESPACE
+using namespace std;
+#endif
+
+
+
+
+#ifdef USES_NAMESPACE
+namespace astyle
+ {
+#endif
+
+ bool ASBeautifier::calledInitStatic = false;
+
+ vector<const string*> ASBeautifier::headers;
+ vector<const string*> ASBeautifier::nonParenHeaders;
+ vector<const string*> ASBeautifier::preBlockStatements;
+ vector<const string*> ASBeautifier::assignmentOperators;
+ vector<const string*> ASBeautifier::nonAssignmentOperators;
+
+ /*
+ * initialize the static vars
+ */
+ void ASBeautifier::initStatic()
+ {
+ if (calledInitStatic)
+ return;
+
+ calledInitStatic = true;
+
+ headers.push_back(&AS_IF);
+ headers.push_back(&AS_ELSE);
+ headers.push_back(&AS_FOR);
+ headers.push_back(&AS_WHILE);
+ headers.push_back(&AS_DO);
+ headers.push_back(&AS_TRY);
+ headers.push_back(&AS_CATCH);
+ headers.push_back(&AS_FINALLY);
+ headers.push_back(&AS_SYNCHRONIZED);
+ headers.push_back(&AS_SWITCH);
+ headers.push_back(&AS_CASE);
+ headers.push_back(&AS_DEFAULT);
+ headers.push_back(&AS_FOREACH);
+ headers.push_back(&AS_LOCK);
+ headers.push_back(&AS_UNSAFE);
+ headers.push_back(&AS_FIXED);
+ headers.push_back(&AS_GET);
+ headers.push_back(&AS_SET);
+ headers.push_back(&AS_ADD);
+ headers.push_back(&AS_REMOVE);
+ //headers.push_back(&AS_PUBLIC);
+ //headers.push_back(&AS_PRIVATE);
+ //headers.push_back(&AS_PROTECTED);
+
+ //headers.push_back(&AS_OPERATOR);
+ headers.push_back(&AS_TEMPLATE);
+ headers.push_back(&AS_CONST);
+ /**/
+ headers.push_back(&AS_STATIC);
+ headers.push_back(&AS_EXTERN);
+
+ nonParenHeaders.push_back(&AS_ELSE);
+ nonParenHeaders.push_back(&AS_DO);
+ nonParenHeaders.push_back(&AS_TRY);
+ nonParenHeaders.push_back(&AS_FINALLY);
+ nonParenHeaders.push_back(&AS_STATIC);
+ nonParenHeaders.push_back(&AS_CONST);
+ nonParenHeaders.push_back(&AS_EXTERN);
+ nonParenHeaders.push_back(&AS_CASE);
+ nonParenHeaders.push_back(&AS_DEFAULT);
+ nonParenHeaders.push_back(&AS_UNSAFE);
+ nonParenHeaders.push_back(&AS_GET);
+ nonParenHeaders.push_back(&AS_SET);
+ nonParenHeaders.push_back(&AS_ADD);
+ nonParenHeaders.push_back(&AS_REMOVE);
+
+
+
+ nonParenHeaders.push_back(&AS_PUBLIC);
+ nonParenHeaders.push_back(&AS_PRIVATE);
+ nonParenHeaders.push_back(&AS_PROTECTED);
+ nonParenHeaders.push_back(&AS_TEMPLATE);
+ nonParenHeaders.push_back(&AS_CONST);
+ /// nonParenHeaders.push_back(&AS_ASM);
+
+ preBlockStatements.push_back(&AS_CLASS);
+ preBlockStatements.push_back(&AS_STRUCT);
+ preBlockStatements.push_back(&AS_UNION);
+ preBlockStatements.push_back(&AS_INTERFACE);
+ preBlockStatements.push_back(&AS_NAMESPACE);
+ preBlockStatements.push_back(&AS_THROWS);
+ preBlockStatements.push_back(&AS_EXTERN);
+
+ assignmentOperators.push_back(&AS_ASSIGN);
+ assignmentOperators.push_back(&AS_PLUS_ASSIGN);
+ assignmentOperators.push_back(&AS_MINUS_ASSIGN);
+ assignmentOperators.push_back(&AS_MULT_ASSIGN);
+ assignmentOperators.push_back(&AS_DIV_ASSIGN);
+ assignmentOperators.push_back(&AS_MOD_ASSIGN);
+ assignmentOperators.push_back(&AS_OR_ASSIGN);
+ assignmentOperators.push_back(&AS_AND_ASSIGN);
+ assignmentOperators.push_back(&AS_XOR_ASSIGN);
+ assignmentOperators.push_back(&AS_GR_GR_GR_ASSIGN);
+ assignmentOperators.push_back(&AS_GR_GR_ASSIGN);
+ assignmentOperators.push_back(&AS_LS_LS_LS_ASSIGN);
+ assignmentOperators.push_back(&AS_LS_LS_ASSIGN);
+
+ assignmentOperators.push_back(&AS_RETURN);
+
+ nonAssignmentOperators.push_back(&AS_EQUAL);
+ nonAssignmentOperators.push_back(&AS_PLUS_PLUS);
+ nonAssignmentOperators.push_back(&AS_MINUS_MINUS);
+ nonAssignmentOperators.push_back(&AS_NOT_EQUAL);
+ nonAssignmentOperators.push_back(&AS_GR_EQUAL);
+ nonAssignmentOperators.push_back(&AS_GR_GR_GR);
+ nonAssignmentOperators.push_back(&AS_GR_GR);
+ nonAssignmentOperators.push_back(&AS_LS_EQUAL);
+ nonAssignmentOperators.push_back(&AS_LS_LS_LS);
+ nonAssignmentOperators.push_back(&AS_LS_LS);
+ nonAssignmentOperators.push_back(&AS_ARROW);
+ nonAssignmentOperators.push_back(&AS_AND);
+ nonAssignmentOperators.push_back(&AS_OR);
+ }
+
+ /**
+ * ASBeautifier's constructor
+ */
+ ASBeautifier::ASBeautifier()
+ {
+ initStatic();
+
+ waitingBeautifierStack = NULL;
+ activeBeautifierStack = NULL;
+ waitingBeautifierStackLengthStack = NULL;
+ activeBeautifierStackLengthStack = NULL;
+
+ headerStack = NULL;
+ tempStacks = NULL;
+ blockParenDepthStack = NULL;
+ blockStatementStack = NULL;
+ parenStatementStack = NULL;
+ bracketBlockStateStack = NULL;
+ inStatementIndentStack = NULL;
+ inStatementIndentStackSizeStack = NULL;
+ parenIndentStack = NULL;
+ sourceIterator = NULL;
+
+ isMinimalConditinalIndentSet = false;
+ shouldForceTabIndentation = false;
+
+ setSpaceIndentation(4);
+ setMaxInStatementIndentLength(40);
+ setClassIndent(false);
+ setSwitchIndent(false);
+ setCaseIndent(false);
+ setBlockIndent(false);
+ setBracketIndent(false);
+ setNamespaceIndent(false);
+ setLabelIndent(false);
+ setEmptyLineFill(false);
+ setCStyle();
+ setPreprocessorIndent(false);
+ }
+
+ ASBeautifier::ASBeautifier(const ASBeautifier &other)
+ {
+ waitingBeautifierStack = NULL;
+ activeBeautifierStack = NULL;
+ waitingBeautifierStackLengthStack = NULL;
+ activeBeautifierStackLengthStack = NULL;
+
+ headerStack = new vector<const string*>;
+ *headerStack = *other.headerStack;
+
+ tempStacks = new vector< vector<const string*>* >;
+ vector< vector<const string*>* >::iterator iter;
+ for (iter = other.tempStacks->begin();
+ iter != other.tempStacks->end();
+ ++iter)
+ {
+ vector<const string*> *newVec = new vector<const string*>;
+ *newVec = **iter;
+ tempStacks->push_back(newVec);
+ }
+ blockParenDepthStack = new vector<int>;
+ *blockParenDepthStack = *other.blockParenDepthStack;
+
+ blockStatementStack = new vector<bool>;
+ *blockStatementStack = *other.blockStatementStack;
+
+ parenStatementStack = new vector<bool>;
+ *parenStatementStack = *other.parenStatementStack;
+
+ bracketBlockStateStack = new vector<bool>;
+ *bracketBlockStateStack = *other.bracketBlockStateStack;
+
+ inStatementIndentStack = new vector<int>;
+ *inStatementIndentStack = *other.inStatementIndentStack;
+
+ inStatementIndentStackSizeStack = new vector<int>;
+ *inStatementIndentStackSizeStack = *other.inStatementIndentStackSizeStack;
+
+ parenIndentStack = new vector<int>;
+ *parenIndentStack = *other.parenIndentStack;
+
+ sourceIterator = other.sourceIterator;
+
+ indentString = other.indentString;
+ currentHeader = other.currentHeader;
+ previousLastLineHeader = other.previousLastLineHeader;
+ immediatelyPreviousAssignmentOp = other.immediatelyPreviousAssignmentOp;
+ isInQuote = other.isInQuote;
+ isInComment = other.isInComment;
+ isInCase = other.isInCase;
+ isInQuestion = other.isInQuestion;
+ isInStatement =other. isInStatement;
+ isInHeader = other.isInHeader;
+ isCStyle = other.isCStyle;
+ isInOperator = other.isInOperator;
+ isInTemplate = other.isInTemplate;
+ isInConst = other.isInConst;
+ classIndent = other.classIndent;
+ isInClassHeader = other.isInClassHeader;
+ isInClassHeaderTab = other.isInClassHeaderTab;
+ switchIndent = other.switchIndent;
+ caseIndent = other.caseIndent;
+ namespaceIndent = other.namespaceIndent;
+ bracketIndent = other.bracketIndent;
+ blockIndent = other.blockIndent;
+ labelIndent = other.labelIndent;
+ preprocessorIndent = other.preprocessorIndent;
+ parenDepth = other.parenDepth;
+ indentLength = other.indentLength;
+ blockTabCount = other.blockTabCount;
+ leadingWhiteSpaces = other.leadingWhiteSpaces;
+ maxInStatementIndent = other.maxInStatementIndent;
+ templateDepth = other.templateDepth;
+ quoteChar = other.quoteChar;
+ prevNonSpaceCh = other.prevNonSpaceCh;
+ currentNonSpaceCh = other.currentNonSpaceCh;
+ currentNonLegalCh = other.currentNonLegalCh;
+ prevNonLegalCh = other.prevNonLegalCh;
+ isInConditional = other.isInConditional;
+ minConditionalIndent = other.minConditionalIndent;
+ prevFinalLineSpaceTabCount = other.prevFinalLineSpaceTabCount;
+ prevFinalLineTabCount = other.prevFinalLineTabCount;
+ emptyLineFill = other.emptyLineFill;
+ probationHeader = other.probationHeader;
+ isInDefine = other.isInDefine;
+ isInDefineDefinition = other.isInDefineDefinition;
+ backslashEndsPrevLine = other.backslashEndsPrevLine;
+ defineTabCount = other.defineTabCount;
+ }
+
+ /**
+ * ASBeautifier's destructor
+ */
+ ASBeautifier::~ASBeautifier()
+ {
+ DELETE_CONTAINER( headerStack );
+ DELETE_CONTAINER( tempStacks );
+ DELETE_CONTAINER( blockParenDepthStack );
+ DELETE_CONTAINER( blockStatementStack );
+ DELETE_CONTAINER( parenStatementStack );
+ DELETE_CONTAINER( bracketBlockStateStack );
+ DELETE_CONTAINER( inStatementIndentStack );
+ DELETE_CONTAINER( inStatementIndentStackSizeStack );
+ DELETE_CONTAINER( parenIndentStack );
+
+ // DELETE_CONTAINER( sourceIterator );
+ }
+
+ /**
+ * initialize the ASBeautifier.
+ *
+ * init() should be called every time a ABeautifier object is to start
+ * beautifying a NEW source file.
+ * init() recieves a pointer to a DYNAMICALLY CREATED ASSourceIterator object
+ * that will be used to iterate through the source code. This object will be
+ * deleted during the ASBeautifier's destruction, and thus should not be
+ * deleted elsewhere.
+ *
+ * @param iter a pointer to the DYNAMICALLY CREATED ASSourceIterator object.
+ */
+ void ASBeautifier::init(ASSourceIterator *iter)
+
+ {
+ sourceIterator = iter;
+ init();
+ }
+
+ /**
+ * initialize the ASBeautifier.
+ */
+ void ASBeautifier::init()
+ {
+ INIT_CONTAINER( waitingBeautifierStack, new vector<ASBeautifier*> );
+ INIT_CONTAINER( activeBeautifierStack, new vector<ASBeautifier*> );
+
+ INIT_CONTAINER( waitingBeautifierStackLengthStack, new vector<int> );
+ INIT_CONTAINER( activeBeautifierStackLengthStack, new vector<int> );
+
+ INIT_CONTAINER( headerStack, new vector<const string*> );
+ INIT_CONTAINER( tempStacks, new vector< vector<const string*>* > );
+ tempStacks->push_back(new vector<const string*>);
+
+ INIT_CONTAINER( blockParenDepthStack, new vector<int> );
+ INIT_CONTAINER( blockStatementStack, new vector<bool> );
+ INIT_CONTAINER( parenStatementStack, new vector<bool> );
+
+ INIT_CONTAINER( bracketBlockStateStack, new vector<bool> );
+ bracketBlockStateStack->push_back(true);
+
+ INIT_CONTAINER( inStatementIndentStack, new vector<int> );
+ INIT_CONTAINER( inStatementIndentStackSizeStack, new vector<int> );
+ inStatementIndentStackSizeStack->push_back(0);
+ INIT_CONTAINER( parenIndentStack, new vector<int> );
+
+ immediatelyPreviousAssignmentOp = NULL;
+ previousLastLineHeader = NULL;
+
+ isInQuote = false;
+ isInComment = false;
+ isInStatement = false;
+ isInCase = false;
+ isInQuestion = false;
+ isInClassHeader = false;
+ isInClassHeaderTab = false;
+ isInHeader = false;
+ isInOperator = false;
+ isInTemplate = false;
+ isInConst = false;
+ isInConditional = false;
+ templateDepth = 0;
+ parenDepth=0;
+ blockTabCount = 0;
+ leadingWhiteSpaces = 0;
+ prevNonSpaceCh = '{';
+ currentNonSpaceCh = '{';
+ prevNonLegalCh = '{';
+ currentNonLegalCh = '{';
+ prevFinalLineSpaceTabCount = 0;
+ prevFinalLineTabCount = 0;
+ probationHeader = NULL;
+ backslashEndsPrevLine = false;
+ isInDefine = false;
+ isInDefineDefinition = false;
+ defineTabCount = 0;
+ }
+
+ /**
+ * set indentation style to ANSI C/C++.
+ */
+ void ASBeautifier::setCStyle()
+ {
+ isCStyle = true;
+ }
+
+ /**
+ * set indentation style to Java / K&R.
+ */
+ void ASBeautifier::setJavaStyle()
+ {
+ isCStyle = false;
+ }
+
+ /**
+ * indent using one tab per indentation
+ */
+ void ASBeautifier::setTabIndentation(int length, bool forceTabs)
+ {
+ indentString = "\t";
+ indentLength = length;
+ shouldForceTabIndentation = forceTabs;
+
+ if (!isMinimalConditinalIndentSet)
+ minConditionalIndent = indentLength * 2;
+ }
+
+ /**
+
+ * indent using a number of spaces per indentation.
+ *
+ * @param length number of spaces per indent.
+ */
+ void ASBeautifier::setSpaceIndentation(int length)
+ {
+ indentString=string(length, ' ');
+ indentLength = length;
+
+ if (!isMinimalConditinalIndentSet)
+ minConditionalIndent = indentLength * 2;
+ }
+
+ /**
+ * set the maximum indentation between two lines in a multi-line statement.
+ *
+ * @param max maximum indentation length.
+ */
+ void ASBeautifier::setMaxInStatementIndentLength(int max)
+ {
+ maxInStatementIndent = max;
+ }
+
+ /**
+ * set the minimum indentation between two lines in a multi-line condition.
+ *
+ * @param min minimal indentation length.
+ */
+ void ASBeautifier::setMinConditionalIndentLength(int min)
+ {
+ minConditionalIndent = min;
+ isMinimalConditinalIndentSet = true;
+ }
+
+ /**
+ * set the state of the bracket indentation option. If true, brackets will
+ * be indented one additional indent.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setBracketIndent(bool state)
+ {
+ bracketIndent = state;
+ }
+
+ /**
+ * set the state of the block indentation option. If true, entire blocks
+ * will be indented one additional indent, similar to the GNU indent style.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setBlockIndent(bool state)
+ {
+ if (state)
+ setBracketIndent(false); // so that we don't have both bracket and block indent
+ blockIndent = state;
+ }
+
+ /**
+ * set the state of the class indentation option. If true, C++ class
+ * definitions will be indented one additional indent.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setClassIndent(bool state)
+ {
+ classIndent = state;
+ }
+
+ /**
+ * set the state of the switch indentation option. If true, blocks of 'switch'
+ * statements will be indented one additional indent.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setSwitchIndent(bool state)
+ {
+ switchIndent = state;
+ }
+
+ /**
+ * set the state of the case indentation option. If true, lines of 'case'
+ * statements will be indented one additional indent.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setCaseIndent(bool state)
+ {
+ caseIndent = state;
+ }
+ /**
+ * set the state of the namespace indentation option.
+ * If true, blocks of 'namespace' statements will be indented one
+ * additional indent. Otherwise, NO indentation will be added.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setNamespaceIndent(bool state)
+ {
+ namespaceIndent = state;
+ }
+
+ /**
+ * set the state of the label indentation option.
+ * If true, labels will be indented one indent LESS than the
+ * current indentation level.
+ * If false, labels will be flushed to the left with NO
+ * indent at all.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setLabelIndent(bool state)
+ {
+ labelIndent = state;
+ }
+
+ /**
+ * set the state of the preprocessor indentation option.
+ * If true, multiline #define statements will be indented.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setPreprocessorIndent(bool state)
+ {
+ preprocessorIndent = state;
+ }
+
+ /**
+ * set the state of the empty line fill option.
+ * If true, empty lines will be filled with the whitespace.
+ * of their previous lines.
+ * If false, these lines will remain empty.
+ *
+ * @param state state of option.
+ */
+ void ASBeautifier::setEmptyLineFill(bool state)
+ {
+ emptyLineFill = state;
+ }
+
+ /**
+ * check if there are any indented lines ready to be read by nextLine()
+ *
+ * @return are there any indented lines ready?
+ */
+ bool ASBeautifier::hasMoreLines() const
+ {
+ return sourceIterator->hasMoreLines();
+ }
+
+ /**
+ * get the next indented line.
+ *
+ * @return indented line.
+ */
+ string ASBeautifier::nextLine()
+ {
+ return beautify(sourceIterator->nextLine());
+ }
+
+ /**
+ * beautify a line of source code.
+ * every line of source code in a source code file should be sent
+ * one after the other to the beautify method.
+ *
+ * @return the indented line.
+ * @param originalLine the original unindented line.
+ */
+ string ASBeautifier::beautify(const string &originalLine)
+ {
+ string line;
+ bool isInLineComment = false;
+ bool lineStartsInComment = false;
+ bool isInClass = false;
+ bool isInSwitch = false;
+ bool isImmediatelyAfterConst = false;
+ bool isSpecialChar = false;
+
+ char ch = ' ';
+ char prevCh;
+ string outBuffer; // the newly idented line is bufferd here
+ int tabCount = 0;
+ const string *lastLineHeader = NULL;
+ bool closingBracketReached = false;
+ int spaceTabCount = 0;
+ char tempCh;
+ unsigned int headerStackSize = headerStack->size();
+ //bool isLineInStatement = isInStatement;
+ bool shouldIndentBrackettedLine = true;
+ int lineOpeningBlocksNum = 0;
+ int lineClosingBlocksNum = 0;
+ bool previousLineProbation = (probationHeader != NULL);
+ unsigned int i;
+
+ currentHeader = NULL;
+
+ lineStartsInComment = isInComment;
+
+ // handle and remove white spaces around the line:
+ // If not in comment, first find out size of white space before line,
+ // so that possible comments starting in the line continue in
+ // relation to the preliminary white-space.
+ if (!isInComment)
+ {
+ leadingWhiteSpaces = 0;
+ while (leadingWhiteSpaces<originalLine.length() && originalLine[leadingWhiteSpaces] <= 0x20)
+ leadingWhiteSpaces++;
+
+ line = trim(originalLine);
+ }
+ else
+ {
+ unsigned int trimSize;
+ for (trimSize=0;
+ trimSize < originalLine.length() && trimSize<leadingWhiteSpaces && originalLine[trimSize] <= 0x20 ;
+ trimSize++)
+ ;
+ line = originalLine.substr(trimSize);
+ }
+
+
+ if (line.length() == 0)
+ {
+ if (emptyLineFill)
+ return preLineWS(prevFinalLineSpaceTabCount, prevFinalLineTabCount);
+ else
+ return line;
+ }
+
+ // handle preprocessor commands
+
+ if (isCStyle && !isInComment && (line[0] == '#' || backslashEndsPrevLine))
+ {
+ if (line[0] == '#')
+ {
+ string preproc = trim(string(line.c_str() + 1));
+
+
+ // When finding a multi-lined #define statement, the original beautifier
+ // 1. sets its isInDefineDefinition flag
+ // 2. clones a new beautifier that will be used for the actual indentation
+ // of the #define. This clone is put into the activeBeautifierStack in order
+ // to be called for the actual indentation.
+ // The original beautifier will have isInDefineDefinition = true, isInDefine = false
+ // The cloned beautifier will have isInDefineDefinition = true, isInDefine = true
+ if (preprocessorIndent && preproc.COMPARE(0, 6, string("define")) == 0 && line[line.length() - 1] == '\\')
+ {
+ if (!isInDefineDefinition)
+ {
+ ASBeautifier *defineBeautifier;
+
+ // this is the original beautifier
+ isInDefineDefinition = true;
+
+ // push a new beautifier into the active stack
+ // this breautifier will be used for the indentation of this define
+ defineBeautifier = new ASBeautifier(*this);
+ //defineBeautifier->init();
+ //defineBeautifier->isInDefineDefinition = true;
+ //defineBeautifier->beautify("");
+ activeBeautifierStack->push_back(defineBeautifier);
+ }
+ else
+ {
+ // the is the cloned beautifier that is in charge of indenting the #define.
+ isInDefine = true;
+ }
+ }
+ else if (preproc.COMPARE(0, 2, string("if")) == 0)
+ {
+ // push a new beautifier into the stack
+ waitingBeautifierStackLengthStack->push_back(waitingBeautifierStack->size());
+ activeBeautifierStackLengthStack->push_back(activeBeautifierStack->size());
+ waitingBeautifierStack->push_back(new ASBeautifier(*this));
+ }
+ else if (preproc.COMPARE(0, 4/*2*/, string("else")) == 0)
+ {
+ if (!waitingBeautifierStack->empty())
+ {
+ // MOVE current waiting beautifier to active stack.
+ activeBeautifierStack->push_back(waitingBeautifierStack->back());
+ waitingBeautifierStack->pop_back();
+ }
+ }
+ else if (preproc.COMPARE(0, 4, string("elif")) == 0)
+ {
+ if (!waitingBeautifierStack->empty())
+ {
+ // append a COPY current waiting beautifier to active stack, WITHOUT deleting the original.
+ activeBeautifierStack->push_back( new ASBeautifier( *(waitingBeautifierStack->back()) ) );
+ }
+ }
+ else if (preproc.COMPARE(0, 5, string("endif")) == 0)
+ {
+ unsigned int stackLength;
+ ASBeautifier *beautifier;
+
+ if (!waitingBeautifierStackLengthStack->empty())
+ {
+ stackLength = waitingBeautifierStackLengthStack->back();
+ waitingBeautifierStackLengthStack->pop_back();
+ while (waitingBeautifierStack->size() > stackLength)
+ {
+ beautifier = waitingBeautifierStack->back();
+ waitingBeautifierStack->pop_back();
+ delete beautifier;
+ }
+ }
+
+ if (!activeBeautifierStackLengthStack->empty())
+ {
+ stackLength = activeBeautifierStackLengthStack->back();
+ activeBeautifierStackLengthStack->pop_back();
+ while (activeBeautifierStack->size() > stackLength)
+ {
+ beautifier = activeBeautifierStack->back();
+ activeBeautifierStack->pop_back();
+ delete beautifier;
+ }
+ }
+
+
+ }
+ }
+
+ // check if the last char is a backslash
+ if(line.length() > 0)
+ backslashEndsPrevLine = (line[line.length() - 1] == '\\');
+ else
+ backslashEndsPrevLine = false;
+
+ // check if this line ends a multi-line #define
+ // if so, use the #define's cloned beautifier for the line's indentation
+ // and then remove it from the active beautifier stack and delete it.
+ if (!backslashEndsPrevLine && isInDefineDefinition && !isInDefine)
+ {
+ string beautifiedLine;
+ ASBeautifier *defineBeautifier;
+
+ isInDefineDefinition = false;
+ defineBeautifier = activeBeautifierStack->back();
+ activeBeautifierStack->pop_back();
+
+ beautifiedLine = defineBeautifier->beautify(line);
+ delete defineBeautifier;
+ return beautifiedLine;
+ }
+
+ // unless this is a multi-line #define, return this precompiler line as is.
+ if (!isInDefine && !isInDefineDefinition)
+ return originalLine;
+ }
+
+ // if there exists any worker beautifier in the activeBeautifierStack,
+ // then use it instead of me to indent the current line.
+ if (!isInDefine && activeBeautifierStack != NULL && !activeBeautifierStack->empty())
+ {
+ return activeBeautifierStack->back()->beautify(line);
+ }
+
+ // calculate preliminary indentation based on data from past lines
+ if (!inStatementIndentStack->empty())
+ spaceTabCount = inStatementIndentStack->back();
+
+
+ for (i=0; i<headerStackSize; i++)
+ {
+ isInClass = false;
+
+ if (blockIndent || (!(i>0 && (*headerStack)[i-1] != &AS_OPEN_BRACKET
+ && (*headerStack)[i] == &AS_OPEN_BRACKET)))
+ ++tabCount;
+
+ if (isCStyle && !namespaceIndent && i >= 1
+ && (*headerStack)[i-1] == &AS_NAMESPACE
+ && (*headerStack)[i] == &AS_OPEN_BRACKET)
+ --tabCount;
+
+ if (isCStyle && i >= 1
+ && (*headerStack)[i-1] == &AS_CLASS
+ && (*headerStack)[i] == &AS_OPEN_BRACKET )
+ {
+ if (classIndent)
+ ++tabCount;
+ isInClass = true;
+ }
+
+ // is the switchIndent option is on, indent switch statements an additional indent.
+ else if (switchIndent && i > 1 &&
+ (*headerStack)[i-1] == &AS_SWITCH &&
+ (*headerStack)[i] == &AS_OPEN_BRACKET
+ )
+ {
+ ++tabCount;
+ isInSwitch = true;
+ }
+
+ }
+
+ if (!lineStartsInComment
+ && isCStyle
+ && isInClass
+ && classIndent
+ && headerStackSize >= 2
+ &&(*headerStack)[headerStackSize-2] == &AS_CLASS
+ && (*headerStack)[headerStackSize-1] == &AS_OPEN_BRACKET
+ && line[0] == '}')
+ --tabCount;
+
+ else if (!lineStartsInComment
+ && isInSwitch
+ && switchIndent
+ && headerStackSize >= 2
+ && (*headerStack)[headerStackSize-2] == &AS_SWITCH
+ && (*headerStack)[headerStackSize-1] == &AS_OPEN_BRACKET
+ && line[0] == '}')
+ --tabCount;
+
+ if (isInClassHeader)
+ {
+ isInClassHeaderTab = true;
+ tabCount += 2;
+ }
+
+ if (isInConditional)
+ {
+ --tabCount;
+ }
+
+
+ // parse characters in the current line.
+
+ for (i=0; i<line.length(); i++)
+ {
+ tempCh = line[i];
+
+ prevCh = ch;
+ ch = tempCh;
+
+ outBuffer.append(1, ch);
+
+ if (isWhiteSpace(ch))
+ continue;
+
+
+ // handle special characters (i.e. backslash+character such as \n, \t, ...)
+ if (isSpecialChar)
+ {
+ isSpecialChar = false;
+ continue;
+ }
+ if (!(isInComment || isInLineComment) && line.COMPARE(i, 2, string("\\\\")) == 0)
+ {
+ outBuffer.append(1, '\\');
+ i++;
+ continue;
+ }
+ if (!(isInComment || isInLineComment) && ch=='\\')
+ {
+ isSpecialChar = true;
+ continue;
+ }
+
+ // handle quotes (such as 'x' and "Hello Dolly")
+ if (!(isInComment || isInLineComment) && (ch=='"' || ch=='\''))
+ if (!isInQuote)
+ {
+ quoteChar = ch;
+ isInQuote = true;
+ }
+ else if (quoteChar == ch)
+ {
+ isInQuote = false;
+ isInStatement = true;
+ continue;
+ }
+ if (isInQuote)
+ continue;
+
+ // handle comments
+
+ if ( !(isInComment || isInLineComment) && line.COMPARE(i, 2, AS_OPEN_LINE_COMMENT) == 0 )
+ {
+ isInLineComment = true;
+ outBuffer.append(1, '/');
+ i++;
+ continue;
+ }
+ else if ( !(isInComment || isInLineComment) && line.COMPARE(i, 2, AS_OPEN_COMMENT) == 0 )
+ {
+ isInComment = true;
+ outBuffer.append(1, '*');
+ i++;
+ continue;
+ }
+ else if ( (isInComment || isInLineComment) && line.COMPARE(i, 2, AS_CLOSE_COMMENT) == 0 )
+ {
+ isInComment = false;
+ outBuffer.append(1, '/');
+ i++;
+ continue;
+ }
+
+ if (isInComment||isInLineComment)
+ continue;
+
+ // if we have reached this far then we are NOT in a comment or string of special character...
+
+ if (probationHeader != NULL)
+ {
+ if ( ((probationHeader == &AS_STATIC || probationHeader == &AS_CONST) && ch == '{')
+ || (probationHeader == &AS_SYNCHRONIZED && ch == '('))
+ {
+ // insert the probation header as a new header
+ isInHeader = true;
+ headerStack->push_back(probationHeader);
+
+ // handle the specific probation header
+ isInConditional = (probationHeader == &AS_SYNCHRONIZED);
+ if (probationHeader == &AS_CONST)
+ isImmediatelyAfterConst = true;
+ // isInConst = true;
+ /* TODO:
+ * There is actually no more need for the global isInConst variable.
+ * The only reason for checking const is to see if there is a const
+ * immediately before an open-bracket.
+ * Since CONST is now put into probation and is checked during itspost-char,
+ * isImmediatelyAfterConst can be set by its own...
+ */
+
+ isInStatement = false;
+ // if the probation comes from the previous line, then indent by 1 tab count.
+ if (previousLineProbation && ch == '{')
+ tabCount++;
+ previousLineProbation = false;
+ }
+
+ // dismiss the probation header
+ probationHeader = NULL;
+ }
+
+ prevNonSpaceCh = currentNonSpaceCh;
+ currentNonSpaceCh = ch;
+ if (!isLegalNameChar(ch) && ch != ',' && ch != ';' )
+ {
+ prevNonLegalCh = currentNonLegalCh;
+ currentNonLegalCh = ch;
+ }
+
+ //if (isInConst)
+ //{
+ // isInConst = false;
+ // isImmediatelyAfterConst = true;
+ //}
+
+ if (isInHeader)
+ {
+ isInHeader = false;
+ currentHeader = headerStack->back();
+ }
+ else
+ currentHeader = NULL;
+
+ if (isCStyle && isInTemplate
+ && (ch == '<' || ch == '>')
+ && findHeader(line, i, nonAssignmentOperators) == NULL) //;
+ {
+ if (ch == '<')
+ {
+ ++templateDepth;
+ }
+ else if (ch == '>')
+ {
+ if (--templateDepth <= 0)
+ {
+ if (isInTemplate)
+ ch = ';';
+ else
+ ch = 't';
+ isInTemplate = false;
+ templateDepth = 0;
+ }
+
+ }
+ }
+
+ // handle parenthesies
+ if (ch == '(' || ch == '[' || ch == ')' || ch == ']')
+ {
+ if (ch == '(' || ch == '[')
+ {
+ if (parenDepth == 0)
+ {
+ parenStatementStack->push_back(isInStatement);
+ isInStatement = true;
+ }
+ parenDepth++;
+
+ inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
+
+ if (currentHeader != NULL)
+ registerInStatementIndent(line, i, spaceTabCount, minConditionalIndent/*indentLength*2*/, true);
+ else
+ registerInStatementIndent(line, i, spaceTabCount, 0, true);
+ }
+ else if (ch == ')' || ch == ']')
+ {
+ parenDepth--;
+ if (parenDepth == 0)
+ {
+ isInStatement = parenStatementStack->back();
+ parenStatementStack->pop_back();
+ ch = ' ';
+
+ isInConditional = false;
+ }
+
+ if (!inStatementIndentStackSizeStack->empty())
+ {
+ unsigned int previousIndentStackSize = inStatementIndentStackSizeStack->back();
+ inStatementIndentStackSizeStack->pop_back();
+ while (previousIndentStackSize < inStatementIndentStack->size())
+ inStatementIndentStack->pop_back();
+
+ if (!parenIndentStack->empty())
+ {
+ int poppedIndent = parenIndentStack->back();
+ parenIndentStack->pop_back();
+
+ if (i == 0)
+ spaceTabCount = poppedIndent;
+ }
+ }
+ }
+
+ continue;
+ }
+
+
+ if (ch == '{')
+ {
+ bool isBlockOpener = false;
+
+ // first, check if '{' is a block-opener or an static-array opener
+ isBlockOpener = ( (prevNonSpaceCh == '{' && bracketBlockStateStack->back())
+ || prevNonSpaceCh == '}'
+ || prevNonSpaceCh == ')'
+ || prevNonSpaceCh == ';'
+ || isInClassHeader
+ || isBlockOpener
+ || isImmediatelyAfterConst
+ || (isInDefine &&
+ (prevNonSpaceCh == '('
+ || prevNonSpaceCh == '_'
+ || isalnum(prevNonSpaceCh))) );
+
+ isInClassHeader = false;
+ if (!isBlockOpener && currentHeader != NULL)
+ {
+ for (unsigned int n=0; n < nonParenHeaders.size(); n++)
+ if (currentHeader == nonParenHeaders[n])
+ {
+ isBlockOpener = true;
+ break;
+ }
+ }
+ bracketBlockStateStack->push_back(isBlockOpener);
+ if (!isBlockOpener)
+ {
+ inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
+ registerInStatementIndent(line, i, spaceTabCount, 0, true);
+ parenDepth++;
+ if (i == 0)
+ shouldIndentBrackettedLine = false;
+
+ continue;
+ }
+
+ // this bracket is a block opener...
+
+ ++lineOpeningBlocksNum;
+
+ if (isInClassHeader)
+ isInClassHeader = false;
+ if (isInClassHeaderTab)
+ {
+ isInClassHeaderTab = false;
+ tabCount -= 2;
+ }
+
+ blockParenDepthStack->push_back(parenDepth);
+ blockStatementStack->push_back(isInStatement);
+
+ inStatementIndentStackSizeStack->push_back(inStatementIndentStack->size());
+
+ blockTabCount += isInStatement? 1 : 0;
+ parenDepth = 0;
+ isInStatement = false;
+
+ tempStacks->push_back(new vector<const string*>);
+ headerStack->push_back(&AS_OPEN_BRACKET);
+ lastLineHeader = &AS_OPEN_BRACKET; // <------
+
+ continue;
+ }
+
+ //check if a header has been reached
+ if (prevCh == ' ')
+ {
+ bool isIndentableHeader = true;
+ const string *newHeader = findHeader(line, i, headers);
+ if (newHeader != NULL)
+ {
+ // if we reached here, then this is a header...
+ isInHeader = true;
+
+ vector<const string*> *lastTempStack;
+ if (tempStacks->empty())
+ lastTempStack = NULL;
+ else
+ lastTempStack = tempStacks->back();
+
+ // if a new block is opened, push a new stack into tempStacks to hold the
+ // future list of headers in the new block.
+
+ // take care of the special case: 'else if (...)'
+ if (newHeader == &AS_IF && lastLineHeader == &AS_ELSE)
+ {
+ //spaceTabCount += indentLength; // to counter the opposite addition that occurs when the 'if' is registered below...
+ headerStack->pop_back();
+ }
+
+ // take care of 'else'
+ else if (newHeader == &AS_ELSE)
+ {
+ if (lastTempStack != NULL)
+ {
+ int indexOfIf = indexOf(*lastTempStack, &AS_IF); // <---
+ if (indexOfIf != -1)
+ {
+ // recreate the header list in headerStack up to the previous 'if'
+ // from the temporary snapshot stored in lastTempStack.
+ int restackSize = lastTempStack->size() - indexOfIf - 1;
+ for (int r=0; r<restackSize; r++)
+ {
+ headerStack->push_back(lastTempStack->back());
+ lastTempStack->pop_back();
+ }
+ if (!closingBracketReached)
+ tabCount += restackSize;
+ }
+ /*
+ * If the above if is not true, i.e. no 'if' before the 'else',
+ * then nothing beautiful will come out of this...
+ * I should think about inserting an Exception here to notify the caller of this...
+ */
+ }
+ }
+
+ // check if 'while' closes a previous 'do'
+ else if (newHeader == &AS_WHILE)
+ {
+ if (lastTempStack != NULL)
+ {
+ int indexOfDo = indexOf(*lastTempStack, &AS_DO); // <---
+ if (indexOfDo != -1)
+ {
+ // recreate the header list in headerStack up to the previous 'do'
+ // from the temporary snapshot stored in lastTempStack.
+ int restackSize = lastTempStack->size() - indexOfDo - 1;
+ for (int r=0; r<restackSize; r++)
+ {
+ headerStack->push_back(lastTempStack->back());
+ lastTempStack->pop_back();
+ }
+ if (!closingBracketReached)
+ tabCount += restackSize;
+ }
+ }
+ }
+ // check if 'catch' closes a previous 'try' or 'catch'
+ else if (newHeader == &AS_CATCH || newHeader == &AS_FINALLY)
+ {
+ if (lastTempStack != NULL)
+ {
+ int indexOfTry = indexOf(*lastTempStack, &AS_TRY);
+ if (indexOfTry == -1)
+ indexOfTry = indexOf(*lastTempStack, &AS_CATCH);
+ if (indexOfTry != -1)
+ {
+ // recreate the header list in headerStack up to the previous 'try'
+ // from the temporary snapshot stored in lastTempStack.
+ int restackSize = lastTempStack->size() - indexOfTry - 1;
+ for (int r=0; r<restackSize; r++)
+ {
+ headerStack->push_back(lastTempStack->back());
+ lastTempStack->pop_back();
+ }
+
+ if (!closingBracketReached)
+ tabCount += restackSize;
+ }
+ }
+ }
+ else if (newHeader == &AS_CASE)
+ {
+ isInCase = true;
+ if (!caseIndent)
+ --tabCount;
+ }
+ else if(newHeader == &AS_DEFAULT)
+ {
+ isInCase = true;
+ if (!caseIndent)
+ --tabCount;
+ }
+ else if (newHeader == &AS_PUBLIC || newHeader == &AS_PROTECTED || newHeader == &AS_PRIVATE)
+ {
+ if (isCStyle && !isInClassHeader)
+ --tabCount;
+ isIndentableHeader = false;
+ }
+ //else if ((newHeader == &STATIC || newHeader == &SYNCHRONIZED) &&
+ // !headerStack->empty() &&
+ // (headerStack->back() == &STATIC || headerStack->back() == &SYNCHRONIZED))
+ //{
+ // isIndentableHeader = false;
+ //}
+ else if (newHeader == &AS_STATIC
+ || newHeader == &AS_SYNCHRONIZED
+ || (newHeader == &AS_CONST && isCStyle))
+ {
+ if (!headerStack->empty() &&
+ (headerStack->back() == &AS_STATIC
+ || headerStack->back() == &AS_SYNCHRONIZED
+ || headerStack->back() == &AS_CONST))
+ {
+ isIndentableHeader = false;
+ }
+ else
+ {
+ isIndentableHeader = false;
+ probationHeader = newHeader;
+ }
+ }
+ else if (newHeader == &AS_CONST)
+ {
+ // this will be entered only if NOT in C style
+ // since otherwise the CONST would be found to be a probstion header...
+
+ //if (isCStyle)
+ // isInConst = true;
+ isIndentableHeader = false;
+ }
+ /*
+ else if (newHeader == &OPERATOR)
+ {
+ if (isCStyle)
+ isInOperator = true;
+ isIndentableHeader = false;
+ }
+ */
+ else if (newHeader == &AS_TEMPLATE)
+ {
+ if (isCStyle)
+ isInTemplate = true;
+ isIndentableHeader = false;
+ }
+
+
+ if (isIndentableHeader)
+ {
+ // 3.2.99
+ //spaceTabCount-=indentLength;
+ headerStack->push_back(newHeader);
+ isInStatement = false;
+ if (indexOf(nonParenHeaders, newHeader) == -1)
+ {
+ isInConditional = true;
+ }
+ lastLineHeader = newHeader;
+ }
+ else
+ isInHeader = false;
+
+ //lastLineHeader = newHeader;
+
+ outBuffer.append(newHeader->substr(1));
+ i += newHeader->length() - 1;
+
+ continue;
+ }
+ }
+
+ if (isCStyle && !isalpha(prevCh)
+ && line.COMPARE(i, 8, AS_OPERATOR) == 0 && !isalnum(line[i+8]))
+ {
+ isInOperator = true;
+ outBuffer.append(AS_OPERATOR.substr(1));
+ i += 7;
+ continue;
+ }
+
+ if (ch == '?')
+ isInQuestion = true;
+
+
+ // special handling of 'case' statements
+ if (ch == ':')
+ {
+ if (line.length() > i+1 && line[i+1] == ':') // look for ::
+ {
+ ++i;
+ outBuffer.append(1, ':');
+ ch = ' ';
+ continue;
+ }
+
+ else if (isCStyle && isInClass && prevNonSpaceCh != ')')
+ {
+ // BEGIN Content of ASBeautifier.cpp.BITFIELD.patch:
+
+ unsigned int chIndex;
+ char nextCh = 0;
+ for (chIndex = i+1; chIndex < line.length(); chIndex++)
+ if (!isWhiteSpace(line[chIndex]))
+ break;
+ if (chIndex< line.length())
+ nextCh = line[chIndex];
+ int nWord =0;
+ for (chIndex = 0; chIndex < i; chIndex++)
+ {
+ if (!isWhiteSpace(line[chIndex]))
+ {
+ nWord ++;
+ while (!isWhiteSpace(line[++chIndex]));
+ }
+ }
+ if ((nextCh >= '0' && nextCh <= '9') || (nWord >1))
+ continue;
+ // END Content of ASBeautifier.cpp.BITFIELD.patch:
+
+ --tabCount;
+ // found a 'private:' or 'public:' inside a class definition
+ // so do nothing special
+ }
+
+ else if (isCStyle && isInClassHeader)
+ {
+
+ // found a 'class A : public B' definition
+ // so do nothing special
+ }
+
+ else if (isInQuestion)
+ {
+ isInQuestion = false;
+ }
+ else if (isCStyle && prevNonSpaceCh == ')')
+ {
+ isInClassHeader = true;
+ if (i==0)
+ tabCount += 2;
+ }
+ else
+ {
+ currentNonSpaceCh = ';'; // so that brackets after the ':' will appear as block-openers
+ if (isInCase)
+ {
+ isInCase = false;
+ ch = ';'; // from here on, treat char as ';'
+ }
+ // BEGIN content of ASBeautifier.cpp.BITFIELD.patch.bz2
+ else // bitfield or labels
+ {
+ unsigned int chIndex;
+ char nextCh = 0;
+ for (chIndex = i+1; (isCStyle && chIndex < line.length()); chIndex++)
+ if (!isWhiteSpace(line[chIndex]))
+ break;
+ if (chIndex< line.length())
+ nextCh = line[chIndex];
+
+ int nWord =0;
+ for (chIndex = 0; chIndex < i; chIndex++)
+ {
+ if (!isWhiteSpace(line[chIndex]))
+ {
+ nWord ++;
+ while (!isWhiteSpace(line[++chIndex]));
+ }
+ }
+ if (isCStyle && (nextCh >= '0' && nextCh <= '9') || (nWord >1))
+ {
+ continue;
+ }
+ // END content of ASASBeautifier.cpp.BITFIELD.patch.bz2
+
+ else // is in a label (e.g. 'label1:')
+ {
+ if (labelIndent)
+ --tabCount; // unindent label by one indent
+ else
+ tabCount = 0; // completely flush indent to left
+ }
+
+ // BEGIN content of ASASBeautifier.cpp.BITFIELD.patch.bz2
+ }
+ // END content of ASASBeautifier.cpp.BITFIELD.patch.bz2
+
+ }
+ }
+
+ if ((ch == ';' || (parenDepth>0 && ch == ',')) && !inStatementIndentStackSizeStack->empty())
+ while ((unsigned int)inStatementIndentStackSizeStack->back() + (parenDepth>0 ? 1 : 0) < inStatementIndentStack->size())
+ inStatementIndentStack->pop_back();
+
+
+ // handle ends of statements
+ if ( (ch == ';' && parenDepth == 0) || ch == '}'/* || (ch == ',' && parenDepth == 0)*/)
+ {
+ if (ch == '}')
+ {
+ // first check if this '}' closes a previous block, or a static array...
+ if (!bracketBlockStateStack->empty())
+ {
+ bool bracketBlockState = bracketBlockStateStack->back();
+ bracketBlockStateStack->pop_back();
+ if (!bracketBlockState)
+ {
+ if (!inStatementIndentStackSizeStack->empty())
+ {
+ // this bracket is a static array
+
+ unsigned int previousIndentStackSize = inStatementIndentStackSizeStack->back();
+ inStatementIndentStackSizeStack->pop_back();
+ while (previousIndentStackSize < inStatementIndentStack->size())
+ inStatementIndentStack->pop_back();
+ parenDepth--;
+ if (i == 0)
+ shouldIndentBrackettedLine = false;
+
+ if (!parenIndentStack->empty())
+ {
+ int poppedIndent = parenIndentStack->back();
+ parenIndentStack->pop_back();
+ if (i == 0)
+ spaceTabCount = poppedIndent;
+ }
+ }
+ continue;
+ }
+ }
+
+ // this bracket is block closer...
+
+ ++lineClosingBlocksNum;
+
+ if(!inStatementIndentStackSizeStack->empty())
+ inStatementIndentStackSizeStack->pop_back();
+
+ if (!blockParenDepthStack->empty())
+ {
+ parenDepth = blockParenDepthStack->back();
+ blockParenDepthStack->pop_back();
+ isInStatement = blockStatementStack->back();
+ blockStatementStack->pop_back();
+
+ if (isInStatement)
+ blockTabCount--;
+ }
+
+ closingBracketReached = true;
+ int headerPlace = indexOf(*headerStack, &AS_OPEN_BRACKET); // <---
+ if (headerPlace != -1)
+ {
+ const string *popped = headerStack->back();
+ while (popped != &AS_OPEN_BRACKET)
+ {
+ headerStack->pop_back();
+ popped = headerStack->back();
+ }
+ headerStack->pop_back();
+
+ if (!tempStacks->empty())
+ {
+ vector<const string*> *temp = tempStacks->back();
+ tempStacks->pop_back();
+ delete temp;
+ }
+ }
+
+
+ ch = ' '; // needed due to cases such as '}else{', so that headers ('else' tn tih case) will be identified...
+ }
+
+ /*
+ * Create a temporary snapshot of the current block's header-list in the
+ * uppermost inner stack in tempStacks, and clear the headerStack up to
+ * the begining of the block.
+ * Thus, the next future statement will think it comes one indent past
+ * the block's '{' unless it specifically checks for a companion-header
+ * (such as a previous 'if' for an 'else' header) within the tempStacks,
+ * and recreates the temporary snapshot by manipulating the tempStacks.
+ */
+ if (!tempStacks->back()->empty())
+ while (!tempStacks->back()->empty())
+ tempStacks->back()->pop_back();
+ while (!headerStack->empty() && headerStack->back() != &AS_OPEN_BRACKET)
+ {
+ tempStacks->back()->push_back(headerStack->back());
+ headerStack->pop_back();
+ }
+
+ if (parenDepth == 0 && ch == ';')
+ isInStatement=false;
+
+ isInClassHeader = false;
+
+ continue;
+ }
+
+
+ // check for preBlockStatements ONLY if not within parenthesies
+ // (otherwise 'struct XXX' statements would be wrongly interpreted...)
+ if (prevCh == ' ' && !isInTemplate && parenDepth == 0)
+ {
+ const string *newHeader = findHeader(line, i, preBlockStatements);
+ if (newHeader != NULL)
+ {
+ isInClassHeader = true;
+ outBuffer.append(newHeader->substr(1));
+ i += newHeader->length() - 1;
+ //if (isCStyle)
+ headerStack->push_back(newHeader);
+ }
+ }
+
+ // Handle operators
+ //
+
+ //// // PRECHECK if a '==' or '--' or '++' operator was reached.
+ //// // If not, then register an indent IF an assignment operator was reached.
+ //// // The precheck is important, so that statements such as 'i--==2' are not recognized
+ //// // to have assignment operators (here, '-=') in them . . .
+
+ const string *foundAssignmentOp = NULL;
+ const string *foundNonAssignmentOp = NULL;
+
+ immediatelyPreviousAssignmentOp = NULL;
+
+ // Check if an operator has been reached.
+ foundAssignmentOp = findHeader(line, i, assignmentOperators, false);
+ foundNonAssignmentOp = findHeader(line, i, nonAssignmentOperators, false);
+
+ // Since findHeader's boundry checking was not used above, it is possible
+ // that both an assignment op and a non-assignment op where found,
+ // e.g. '>>' and '>>='. If this is the case, treat the LONGER one as the
+ // found operator.
+ if (foundAssignmentOp != NULL && foundNonAssignmentOp != NULL)
+ if (foundAssignmentOp->length() < foundNonAssignmentOp->length())
+ foundAssignmentOp = NULL;
+ else
+ foundNonAssignmentOp = NULL;
+
+ if (foundNonAssignmentOp != NULL)
+ {
+ if (foundNonAssignmentOp->length() > 1)
+ {
+ outBuffer.append(foundNonAssignmentOp->substr(1));
+ i += foundNonAssignmentOp->length() - 1;
+ }
+ }
+
+ else if (foundAssignmentOp != NULL)
+
+ {
+ if (foundAssignmentOp->length() > 1)
+ {
+ outBuffer.append(foundAssignmentOp->substr(1));
+ i += foundAssignmentOp->length() - 1;
+ }
+
+ if (!isInOperator && !isInTemplate)
+ {
+ registerInStatementIndent(line, i, spaceTabCount, 0, false);
+ immediatelyPreviousAssignmentOp = foundAssignmentOp;
+ isInStatement = true;
+ }
+ }
+
+ /*
+ immediatelyPreviousAssignmentOp = NULL;
+ bool isNonAssingmentOperator = false;
+ for (int n = 0; n < nonAssignmentOperators.size(); n++)
+ if (line.COMPARE(i, nonAssignmentOperators[n]->length(), *(nonAssignmentOperators[n])) == 0)
+ {
+ if (nonAssignmentOperators[n]->length() > 1)
+ {
+ outBuffer.append(nonAssignmentOperators[n]->substr(1));
+ i += nonAssignmentOperators[n]->length() - 1;
+ }
+ isNonAssingmentOperator = true;
+ break;
+ }
+ if (!isNonAssingmentOperator)
+ {
+ for (int a = 0; a < assignmentOperators.size(); a++)
+ if (line.COMPARE(i, assignmentOperators[a]->length(), *(assignmentOperators[a])) == 0)
+ {
+ if (assignmentOperators[a]->length() > 1)
+ {
+ outBuffer.append(assignmentOperators[a]->substr(1));
+ i += assignmentOperators[a]->length() - 1;
+ }
+
+ if (!isInOperator && !isInTemplate)
+ {
+ registerInStatementIndent(line, i, spaceTabCount, 0, false);
+ immediatelyPreviousAssignmentOp = assignmentOperators[a];
+ isInStatement = true;
+ }
+ break;
+ }
+ }
+ */
+
+ if (isInOperator)
+ isInOperator = false;
+ }
+
+ // handle special cases of unindentation:
+
+ /*
+ * if '{' doesn't follow an immediately previous '{' in the headerStack
+ * (but rather another header such as "for" or "if", then unindent it
+ * by one indentation relative to its block.
+ */
+ // cerr << endl << lineOpeningBlocksNum << " " << lineClosingBlocksNum << " " << previousLastLineHeader << endl;
+
+ // indent #define lines with one less tab
+ //if (isInDefine)
+ // tabCount -= defineTabCount-1;
+
+
+ if (!lineStartsInComment
+ && !blockIndent
+ && outBuffer.length()>0
+ && outBuffer[0]=='{'
+ && !(lineOpeningBlocksNum > 0 && lineOpeningBlocksNum == lineClosingBlocksNum)
+ && !(headerStack->size() > 1 && (*headerStack)[headerStack->size()-2] == &AS_OPEN_BRACKET)
+ && shouldIndentBrackettedLine)
+ --tabCount;
+
+ else if (!lineStartsInComment
+ && outBuffer.length()>0
+ && outBuffer[0]=='}'
+ && shouldIndentBrackettedLine )
+ --tabCount;
+
+ // correctly indent one-line-blocks...
+ else if (!lineStartsInComment
+ && outBuffer.length()>0
+ && lineOpeningBlocksNum > 0
+ && lineOpeningBlocksNum == lineClosingBlocksNum
+ && previousLastLineHeader != NULL
+ && previousLastLineHeader != &AS_OPEN_BRACKET)
+ tabCount -= 1; //lineOpeningBlocksNum - (blockIndent ? 1 : 0);
+
+ if (tabCount < 0)
+ tabCount = 0;
+
+ // take care of extra bracket indentatation option...
+ if (bracketIndent && outBuffer.length()>0 && shouldIndentBrackettedLine)
+ if (outBuffer[0]=='{' || outBuffer[0]=='}')
+ tabCount++;
+
+
+ if (isInDefine)
+ {
+ if (outBuffer[0] == '#')
+ {
+ string preproc = trim(string(outBuffer.c_str() + 1));
+ if (preproc.COMPARE(0, 6, string("define")) == 0)
+ {
+ if (!inStatementIndentStack->empty()
+ && inStatementIndentStack->back() > 0)
+ {
+ defineTabCount = tabCount;
+ }
+ else
+ {
+ defineTabCount = tabCount - 1;
+ tabCount--;
+ }
+ }
+ }
+
+ tabCount -= defineTabCount;
+ }
+
+ if (tabCount < 0)
+ tabCount = 0;
+
+
+ // finally, insert indentations into begining of line
+
+ prevFinalLineSpaceTabCount = spaceTabCount;
+ prevFinalLineTabCount = tabCount;
+
+ if (shouldForceTabIndentation)
+ {
+ tabCount += spaceTabCount / indentLength;
+ spaceTabCount = spaceTabCount % indentLength;
+ }
+
+ outBuffer = preLineWS(spaceTabCount,tabCount) + outBuffer;
+
+ if (lastLineHeader != NULL)
+ previousLastLineHeader = lastLineHeader;
+
+ return outBuffer;
+ }
+
+
+ string ASBeautifier::preLineWS(int spaceTabCount, int tabCount)
+ {
+ string ws;
+
+ for (int i=0; i<tabCount; i++)
+ ws += indentString;
+
+ while ((spaceTabCount--) > 0)
+ ws += string(" ");
+
+ return ws;
+
+ }
+
+ /**
+ * register an in-statement indent.
+ */
+ void ASBeautifier::registerInStatementIndent(const string &line, int i, int spaceTabCount,
+ int minIndent, bool updateParenStack)
+ {
+ int inStatementIndent;
+ int remainingCharNum = line.length() - i;
+ int nextNonWSChar = 1;
+
+ nextNonWSChar = getNextProgramCharDistance(line, i);
+
+ // if indent is around the last char in the line, indent instead 2 spaces from the previous indent
+ if (nextNonWSChar == remainingCharNum)
+ {
+ int previousIndent = spaceTabCount;
+ if (!inStatementIndentStack->empty())
+ previousIndent = inStatementIndentStack->back();
+
+ inStatementIndentStack->push_back(/*2*/ indentLength + previousIndent );
+ if (updateParenStack)
+ parenIndentStack->push_back( previousIndent );
+ return;
+ }
+
+ if (updateParenStack)
+ parenIndentStack->push_back(i+spaceTabCount);
+
+ inStatementIndent = i + nextNonWSChar + spaceTabCount;
+
+ if (i + nextNonWSChar < minIndent)
+ inStatementIndent = minIndent + spaceTabCount;
+
+ if (i + nextNonWSChar > maxInStatementIndent)
+ inStatementIndent = indentLength*2 + spaceTabCount;
+
+
+
+ if (!inStatementIndentStack->empty() &&
+ inStatementIndent < inStatementIndentStack->back())
+ inStatementIndent = inStatementIndentStack->back();
+
+ inStatementIndentStack->push_back(inStatementIndent);
+ }
+
+ /**
+ * get distance to the next non-white sspace, non-comment character in the line.
+ * if no such character exists, return the length remaining to the end of the line.
+ */
+ int ASBeautifier::getNextProgramCharDistance(const string &line, int i)
+ {
+ bool inComment = false;
+ int remainingCharNum = line.length() - i;
+ int charDistance = 1;
+ int ch;
+
+ for (charDistance = 1; charDistance < remainingCharNum; charDistance++)
+ {
+ ch = line[i + charDistance];
+ if (inComment)
+ {
+ if (line.COMPARE(i + charDistance, 2, AS_CLOSE_COMMENT) == 0)
+ {
+ charDistance++;
+ inComment = false;
+ }
+ continue;
+ }
+ else if (isWhiteSpace(ch))
+ continue;
+ else if (ch == '/')
+ {
+ if (line.COMPARE(i + charDistance, 2, AS_OPEN_LINE_COMMENT) == 0)
+ return remainingCharNum;
+ else if (line.COMPARE(i + charDistance, 2, AS_OPEN_COMMENT) == 0)
+ {
+ charDistance++;
+ inComment = true;
+ }
+ }
+ else
+ return charDistance;
+ }
+
+ return charDistance;
+ }
+
+
+ /**
+ * check if a specific character can be used in a legal variable/method/class name
+ *
+ * @return legality of the char.
+ * @param ch the character to be checked.
+ */
+ bool ASBeautifier::isLegalNameChar(char ch) const
+ {
+ return (isalnum(ch) //(ch>='a' && ch<='z') || (ch>='A' && ch<='Z') || (ch>='0' && ch<='9') ||
+ || ch=='.' || ch=='_' || (!isCStyle && ch=='$') || (isCStyle && ch=='~'));
+ }
+
+
+ /**
+ * check if a specific line position contains a header, out of several possible headers.
+ *
+ * @return a pointer to the found header. if no header was found then return NULL.
+ */
+ const string *ASBeautifier::findHeader(const string &line, int i, const vector<const string*> &possibleHeaders, bool checkBoundry)
+ {
+ int maxHeaders = possibleHeaders.size();
+ const string *header = NULL;
+ int p;
+
+ for (p=0; p < maxHeaders; p++)
+ {
+ header = possibleHeaders[p];
+
+ if (line.COMPARE(i, header->length(), *header) == 0)
+ {
+ // check that this is a header and not a part of a longer word
+ // (e.g. not at its begining, not at its middle...)
+
+ int lineLength = line.length();
+ int headerEnd = i + header->length();
+ char startCh = (*header)[0]; // first char of header
+ char endCh = 0; // char just after header
+ char prevCh = 0; // char just before header
+
+ if (headerEnd < lineLength)
+ {
+ endCh = line[headerEnd];
+ }
+ if (i > 0)
+ {
+ prevCh = line[i-1];
+ }
+
+ if (!checkBoundry)
+ {
+ return header;
+ }
+ else if (prevCh != 0
+ && isLegalNameChar(startCh)
+ && isLegalNameChar(prevCh))
+ {
+ return NULL;
+ }
+ else if (headerEnd >= lineLength
+ || !isLegalNameChar(startCh)
+ || !isLegalNameChar(endCh))
+ {
+ return header;
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ }
+
+ return NULL;
+ }
+
+
+ /**
+ * check if a specific character can be used in a legal variable/method/class name
+ *
+ * @return legality of the char.
+ * @param ch the character to be checked.
+ */
+ bool ASBeautifier::isWhiteSpace(char ch) const
+ {
+ return (ch == ' ' || ch == '\t');
+ }
+
+ /**
+ * find the index number of a string element in a container of strings
+ *
+ * @return the index number of element in the ocntainer. -1 if element not found.
+ * @param container a vector of strings.
+ * @param element the element to find .
+ */
+ int ASBeautifier::indexOf(vector<const string*> &container, const string *element)
+ {
+ vector<const string*>::const_iterator where;
+
+ where= find(container.begin(), container.end(), element);
+ if (where == container.end())
+ return -1;
+ else
+ return where - container.begin();
+ }
+
+ /**
+ * trim removes the white space surrounding a line.
+ *
+ * @return the trimmed line.
+ * @param str the line to trim.
+ */
+ string ASBeautifier::trim(const string &str)
+ {
+
+ int start = 0;
+ int end = str.length() - 1;
+
+ while (start < end && isWhiteSpace(str[start]))
+ start++;
+
+ while (start <= end && isWhiteSpace(str[end]))
+ end--;
+
+ string returnStr(str, start, end+1-start);
+ return returnStr;
+ }
+
+#ifdef USES_NAMESPACE
+}
+#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.
+ */
+
+
+#ifndef ASBEAUTIFIER_H
+#define ASBEAUTIFIER_H
+
+#include "ASResource.h"
+#include "compiler_defines.h"
+#include "ASSourceIterator.h"
+
+#include <string>
+#include <vector>
+
+
+using namespace std;
+
+namespace astyle
+ {
+
+ enum BracketMode { NONE_MODE, ATTACH_MODE, BREAK_MODE, BDAC_MODE };
+ enum BracketType { NULL_TYPE = 0,
+ DEFINITION_TYPE = 1,
+ COMMAND_TYPE = 2,
+ ARRAY_TYPE = 4,
+ SINGLE_LINE_TYPE = 8};
+
+
+ class ASBeautifier : protected ASResource
+ {
+ public:
+ ASBeautifier();
+ virtual ~ASBeautifier();
+ virtual void init(ASSourceIterator* iter); // pointer to dynamically created iterator.
+ virtual void init();
+ virtual bool hasMoreLines() const;
+ virtual string nextLine();
+ virtual string beautify(const string &line);
+ void setTabIndentation(int length = 4, bool forceTabs = false);
+ void setSpaceIndentation(int length = 4);
+ void setMaxInStatementIndentLength(int max);
+ void setMinConditionalIndentLength(int min);
+ void setClassIndent(bool state);
+ void setSwitchIndent(bool state);
+ void setCaseIndent(bool state);
+ void setBracketIndent(bool state);
+ void setBlockIndent(bool state);
+ void setNamespaceIndent(bool state);
+ void setLabelIndent(bool state);
+ void setCStyle();
+ void setJavaStyle();
+ void setEmptyLineFill(bool state);
+ void setPreprocessorIndent(bool state);
+
+
+ protected:
+ int getNextProgramCharDistance(const string &line, int i);
+ bool isLegalNameChar(char ch) const;
+ bool isWhiteSpace(char ch) const;
+ const string *findHeader(const string &line, int i,
+ const vector<const string*> &possibleHeaders,
+ bool checkBoundry = true);
+ string trim(const string &str);
+ int indexOf(vector<const string*> &container, const string *element);
+
+ private:
+ ASBeautifier(const ASBeautifier &copy);
+ void operator=(ASBeautifier&); // not to be implemented
+
+ void initStatic();
+ void registerInStatementIndent(const string &line, int i, int spaceTabCount,
+ int minIndent, bool updateParenStack);
+ string preLineWS(int spaceTabCount, int tabCount);
+
+ static vector<const string*> headers;
+ static vector<const string*> nonParenHeaders;
+ static vector<const string*> preprocessorHeaders;
+ static vector<const string*> preBlockStatements;
+ static vector<const string*> assignmentOperators;
+ static vector<const string*> nonAssignmentOperators;
+
+ static bool calledInitStatic;
+
+ ASSourceIterator *sourceIterator;
+ vector<ASBeautifier*> *waitingBeautifierStack;
+ vector<ASBeautifier*> *activeBeautifierStack;
+ vector<int> *waitingBeautifierStackLengthStack;
+ vector<int> *activeBeautifierStackLengthStack;
+ vector<const string*> *headerStack;
+ vector< vector<const string*>* > *tempStacks;
+ vector<int> *blockParenDepthStack;
+ vector<bool> *blockStatementStack;
+ vector<bool> *parenStatementStack;
+ vector<int> *inStatementIndentStack;
+ vector<int> *inStatementIndentStackSizeStack;
+ vector<int> *parenIndentStack;
+ vector<bool> *bracketBlockStateStack;
+ string indentString;
+ const string *currentHeader;
+ const string *previousLastLineHeader;
+ const string *immediatelyPreviousAssignmentOp;
+ const string *probationHeader;
+ bool isInQuote;
+ bool isInComment;
+ bool isInCase;
+ bool isInQuestion;
+ bool isInStatement;
+ bool isInHeader;
+ bool isCStyle;
+ bool isInOperator;
+ bool isInTemplate;
+ bool isInConst;
+ bool isInDefine;
+ bool isInDefineDefinition;
+ bool classIndent;
+ bool isInClassHeader;
+ bool isInClassHeaderTab;
+ bool switchIndent;
+ bool caseIndent;
+ bool namespaceIndent;
+ bool bracketIndent;
+ bool blockIndent;
+ bool labelIndent;
+ bool preprocessorIndent;
+ bool isInConditional;
+ bool isMinimalConditinalIndentSet;
+ bool shouldForceTabIndentation;
+ int minConditionalIndent;
+ int parenDepth;
+ int indentLength;
+ int blockTabCount;
+ unsigned int leadingWhiteSpaces;
+ int maxInStatementIndent;
+ int templateDepth;
+ char quoteChar;
+ char prevNonSpaceCh;
+ char currentNonSpaceCh;
+ char currentNonLegalCh;
+ char prevNonLegalCh;
+ int prevFinalLineSpaceTabCount;
+ int prevFinalLineTabCount;
+ bool emptyLineFill;
+ bool backslashEndsPrevLine;
+ int defineTabCount;
+ };
+}
+
+#endif
+/*
+ * Copyright (c) 1998,1999,2000,2001,2002 Tal Davidson. All rights reserved.
+ *
+ * ASFormatter.cpp
+ * 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.
+ *
+ *
+ * Patches:
+ * 26 November 1998 - Richard Bullington -
+ * A correction of line-breaking in headers following '}',
+
+ * was created using a variation of a patch by Richard Bullington.
+ * 08 May 2004
+ * applied ASFormatter450670.patch.bz2, ASFormatter.cpp.patch.bz2,
+ * patch1_ssvb_patch.tar.gz
+ */
+
+#include "compiler_defines.h"
+#include "ASFormatter.h"
+
+
+#include <string>
+#include <cctype>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+
+
+#define INIT_CONTAINER(container, value) {if ( (container) != NULL ) delete (container); (container) = (value); }
+#define DELETE_CONTAINER(container) {if ( (container) != NULL ) delete (container) ; }
+#define IS_A(a,b) ( ((a) & (b)) == (b))
+#ifdef USES_NAMESPACE
+using namespace std;
+
+namespace astyle
+ {
+#endif
+
+
+ bool ASFormatter::calledInitStatic = false;
+ vector<const string*> ASFormatter::headers;
+ vector<const string*> ASFormatter::nonParenHeaders;
+ vector<const string*> ASFormatter::preprocessorHeaders;
+ vector<const string*> ASFormatter::preDefinitionHeaders;
+ vector<const string*> ASFormatter::preCommandHeaders;
+ vector<const string*> ASFormatter::operators;
+ vector<const string*> ASFormatter::assignmentOperators;
+
+
+ /**
+ * Constructor of ASFormatter
+ */
+ ASFormatter::ASFormatter()
+ {
+ staticInit();
+
+ preBracketHeaderStack = NULL;
+ bracketTypeStack = NULL;
+ parenStack = NULL;
+
+ sourceIterator = NULL;
+ bracketFormatMode = NONE_MODE;
+ shouldPadOperators = false;
+ shouldPadParenthesies = false;
+ shouldBreakOneLineBlocks = true;
+ shouldBreakOneLineStatements = true;
+ shouldConvertTabs = false;
+ shouldBreakBlocks = false;
+ shouldBreakClosingHeaderBlocks = false;
+ shouldBreakClosingHeaderBrackets = false;
+ shouldBreakElseIfs = false;
+ }
+
+ /**
+ * Destructor of ASFormatter
+ */
+ ASFormatter::~ASFormatter()
+ {
+ DELETE_CONTAINER( preBracketHeaderStack );
+ }
+
+ /**
+ * initialization of static data of ASFormatter.
+ */
+ void ASFormatter::staticInit()
+ {
+ if (calledInitStatic)
+ return;
+
+ calledInitStatic = true;
+
+ headers.push_back(&AS_IF);
+ headers.push_back(&AS_ELSE);
+ headers.push_back(&AS_DO);
+ headers.push_back(&AS_WHILE);
+ headers.push_back(&AS_FOR);
+ headers.push_back(&AS_SYNCHRONIZED);
+ headers.push_back(&AS_TRY);
+ headers.push_back(&AS_CATCH);
+ headers.push_back(&AS_FINALLY);
+ headers.push_back(&AS_SWITCH);
+ headers.push_back(&AS_TEMPLATE);
+ headers.push_back(&AS_FOREACH);
+ headers.push_back(&AS_LOCK);
+ headers.push_back(&AS_UNSAFE);
+ headers.push_back(&AS_FIXED);
+ headers.push_back(&AS_GET);
+ headers.push_back(&AS_SET);
+ headers.push_back(&AS_ADD);
+ headers.push_back(&AS_REMOVE);
+
+ nonParenHeaders.push_back(&AS_ELSE);
+ nonParenHeaders.push_back(&AS_DO);
+ nonParenHeaders.push_back(&AS_TRY);
+ nonParenHeaders.push_back(&AS_FINALLY);
+ nonParenHeaders.push_back(&AS_UNSAFE);
+ nonParenHeaders.push_back(&AS_GET);
+ nonParenHeaders.push_back(&AS_SET);
+ nonParenHeaders.push_back(&AS_ADD);
+ nonParenHeaders.push_back(&AS_REMOVE);
+
+ // nonParenHeaders.push_back(&AS_TEMPLATE);
+
+ preDefinitionHeaders.push_back(&AS_CLASS);
+ preDefinitionHeaders.push_back(&AS_INTERFACE);
+ preDefinitionHeaders.push_back(&AS_NAMESPACE);
+ preDefinitionHeaders.push_back(&AS_STRUCT);
+
+ preCommandHeaders.push_back(&AS_EXTERN);
+ preCommandHeaders.push_back(&AS_THROWS);
+ preCommandHeaders.push_back(&AS_CONST);
+
+ preprocessorHeaders.push_back(&AS_BAR_DEFINE);
+ //// DEVEL: removed the folowing lines
+ ////preprocessorHeaders.push_back(&AS_BAR_INCLUDE);
+ ////preprocessorHeaders.push_back(&AS_BAR_IF); // #if or #ifdef
+ ////preprocessorHeaders.push_back(&AS_BAR_EL); // #else or #elif
+ ////preprocessorHeaders.push_back(&AS_BAR_ENDIF);
+
+ operators.push_back(&AS_PLUS_ASSIGN);
+ operators.push_back(&AS_MINUS_ASSIGN);
+ operators.push_back(&AS_MULT_ASSIGN);
+ operators.push_back(&AS_DIV_ASSIGN);
+ operators.push_back(&AS_MOD_ASSIGN);
+ operators.push_back(&AS_OR_ASSIGN);
+ operators.push_back(&AS_AND_ASSIGN);
+ operators.push_back(&AS_XOR_ASSIGN);
+ operators.push_back(&AS_EQUAL);
+ operators.push_back(&AS_PLUS_PLUS);
+ operators.push_back(&AS_MINUS_MINUS);
+ operators.push_back(&AS_NOT_EQUAL);
+ operators.push_back(&AS_GR_EQUAL);
+ operators.push_back(&AS_GR_GR_GR_ASSIGN);
+ operators.push_back(&AS_GR_GR_ASSIGN);
+ operators.push_back(&AS_GR_GR_GR);
+ operators.push_back(&AS_GR_GR);
+ operators.push_back(&AS_LS_EQUAL);
+ operators.push_back(&AS_LS_LS_LS_ASSIGN);
+ operators.push_back(&AS_LS_LS_ASSIGN);
+ operators.push_back(&AS_LS_LS_LS);
+ operators.push_back(&AS_LS_LS);
+ operators.push_back(&AS_ARROW);
+ operators.push_back(&AS_AND);
+ operators.push_back(&AS_OR);
+ operators.push_back(&AS_COLON_COLON);
+
+ //// BUGFIX: removed the folowing lines
+ //// operators.push_back(&AS_PAREN_PAREN);
+ //// operators.push_back(&AS_BLPAREN_BLPAREN);
+
+ operators.push_back(&AS_PLUS);
+ operators.push_back(&AS_MINUS);
+ operators.push_back(&AS_MULT);
+ operators.push_back(&AS_DIV);
+ operators.push_back(&AS_MOD);
+ operators.push_back(&AS_QUESTION);
+ operators.push_back(&AS_COLON);
+ operators.push_back(&AS_ASSIGN);
+ operators.push_back(&AS_LS);
+ operators.push_back(&AS_GR);
+ operators.push_back(&AS_NOT);
+ operators.push_back(&AS_BIT_OR);
+ operators.push_back(&AS_BIT_AND);
+ operators.push_back(&AS_BIT_NOT);
+ operators.push_back(&AS_BIT_XOR);
+ operators.push_back(&AS_OPERATOR);
+ operators.push_back(&AS_COMMA);
+ //BEGIN Content Patch patch1_ssvb_patch.tar.gz
+ operators.push_back(&AS_SEMICOLON);
+ //END Content Patch patch1_ssvb_patch.tar.gz
+ operators.push_back(&AS_RETURN);
+
+ assignmentOperators.push_back(&AS_PLUS_ASSIGN);
+ assignmentOperators.push_back(&AS_MINUS_ASSIGN);
+ assignmentOperators.push_back(&AS_MULT_ASSIGN);
+ assignmentOperators.push_back(&AS_DIV_ASSIGN);
+ assignmentOperators.push_back(&AS_MOD_ASSIGN);
+ assignmentOperators.push_back(&AS_XOR_ASSIGN);
+ assignmentOperators.push_back(&AS_OR_ASSIGN);
+ assignmentOperators.push_back(&AS_AND_ASSIGN);
+ assignmentOperators.push_back(&AS_GR_GR_GR_ASSIGN);
+ assignmentOperators.push_back(&AS_LS_LS_LS_ASSIGN);
+ assignmentOperators.push_back(&AS_ASSIGN);
+ }
+
+ /**
+ * initialize the ASFormatter.
+ *
+ * init() should be called every time a ASFormatter object is to start
+ * formatting a NEW source file.
+ * init() recieves a pointer to a DYNAMICALLY CREATED ASSourceIterator object
+ * that will be used to iterate through the source code. This object will be
+ * deleted during the ASFormatter's destruction, and thus should not be
+ * deleted elsewhere.
+ *
+ * @param iter a pointer to the DYNAMICALLY CREATED ASSourceIterator object.
+ */
+ void ASFormatter::init(ASSourceIterator *si)
+ {
+ ASBeautifier::init(si);
+ sourceIterator = si;
+
+ INIT_CONTAINER( preBracketHeaderStack, new vector<const string*> );
+ INIT_CONTAINER( bracketTypeStack, new vector<BracketType> );
+ bracketTypeStack->push_back(DEFINITION_TYPE);
+ INIT_CONTAINER( parenStack, new vector<int> );
+ parenStack->push_back(0);
+
+ currentHeader = NULL;
+ currentLine = string("");
+ formattedLine = "";
+ currentChar = ' ';
+ previousCommandChar = ' ';
+ previousNonWSChar = ' ';
+ quoteChar = '"';
+ charNum = 0;
+ previousOperator = NULL;
+
+ isVirgin = true;
+ isInLineComment = false;
+ isInComment = false;
+ isInPreprocessor = false;
+ doesLineStartComment = false;
+ isInQuote = false;
+ isSpecialChar = false;
+ isNonParenHeader = true;
+ foundPreDefinitionHeader = false;
+ foundPreCommandHeader = false;
+ foundQuestionMark = false;
+ isInLineBreak = false;
+ endOfCodeReached = false;
+ isLineReady = false;
+ isPreviousBracketBlockRelated = true;
+ isInPotentialCalculation = false;
+ //foundOneLineBlock = false;
+ shouldReparseCurrentChar = false;
+ passedSemicolon = false;
+ passedColon = false;
+ isInTemplate = false;
+ shouldBreakLineAfterComments = false;
+ isImmediatelyPostComment = false;
+ isImmediatelyPostLineComment = false;
+ isImmediatelyPostEmptyBlock = false;
+
+ isPrependPostBlockEmptyLineRequested = false;
+ isAppendPostBlockEmptyLineRequested = false;
+ prependEmptyLine = false;
+
+ foundClosingHeader = false;
+ previousReadyFormattedLineLength = 0;
+
+ isImmediatelyPostHeader = false;
+ isInHeader = false;
+ }
+
+ /**
+ * get the next formatted line.
+ *
+ * @return formatted line.
+ */
+
+ string ASFormatter::nextLine()
+ {
+ const string *newHeader;
+ bool isCharImmediatelyPostComment = false;
+ bool isPreviousCharPostComment = false;
+ bool isCharImmediatelyPostLineComment = false;
+ bool isInVirginLine = isVirgin;
+ bool isCharImmediatelyPostOpenBlock = false;
+ bool isCharImmediatelyPostCloseBlock = false;
+ bool isCharImmediatelyPostTemplate = false;
+ bool isCharImmediatelyPostHeader = false;
+
+ if (!isFormattingEnabled())
+ return ASBeautifier::nextLine();
+
+ while (!isLineReady)
+ {
+ if (shouldReparseCurrentChar)
+ shouldReparseCurrentChar = false;
+ else if (!getNextChar())
+ {
+ breakLine();
+ return beautify(readyFormattedLine);
+ }
+ else // stuff to do when reading a new character...
+ {
+ // make sure that a virgin '{' at the begining ofthe file will be treated as a block...
+ if (isInVirginLine && currentChar == '{')
+ previousCommandChar = '{';
+ isPreviousCharPostComment = isCharImmediatelyPostComment;
+ isCharImmediatelyPostComment = false;
+ isCharImmediatelyPostTemplate = false;
+ isCharImmediatelyPostHeader = false;
+ }
+
+ if (isInLineComment)
+ {
+ appendCurrentChar();
+
+ // explicitely break a line when a line comment's end is found.
+ if (/*bracketFormatMode == ATTACH_MODE &&*/ charNum+1 == currentLine.length())
+ {
+ isInLineBreak = true;
+ isInLineComment = false;
+ isImmediatelyPostLineComment = true;
+ currentChar = 0; //make sure it is a neutral char.
+ }
+ continue;
+ }
+ else if (isInComment)
+ {
+ if (isSequenceReached(AS_CLOSE_COMMENT))
+ {
+ isInComment = false;
+ isImmediatelyPostComment = true;
+ appendSequence(AS_CLOSE_COMMENT);
+ goForward(1);
+ }
+ else
+ appendCurrentChar();
+
+ continue;
+ }
+
+ // not in line comment or comment
+
+ else if (isInQuote)
+ {
+ if (isSpecialChar)
+ {
+ isSpecialChar = false;
+ appendCurrentChar();
+ }
+ else if (currentChar == '\\')
+ {
+ isSpecialChar = true;
+ appendCurrentChar();
+ }
+ else if (quoteChar == currentChar)
+ {
+ isInQuote = false;
+ appendCurrentChar();
+ }
+ else
+ {
+ appendCurrentChar();
+ }
+
+ continue;
+ }
+
+
+
+ // handle white space - needed to simplify the rest.
+ if (isWhiteSpace(currentChar) || isInPreprocessor)
+ {
+ ////// DEVEL: if (isLegalNameChar(previousChar) && isLegalNameChar(peekNextChar()))
+ appendCurrentChar();
+ continue;
+ }
+
+ /* not in MIDDLE of quote or comment or white-space of any type ... */
+
+ if (isSequenceReached(AS_OPEN_LINE_COMMENT))
+ {
+ isInLineComment = true;
+ if (shouldPadOperators)
+ appendSpacePad();
+ appendSequence(AS_OPEN_LINE_COMMENT);
+ goForward(1);
+ continue;
+ }
+ else if (isSequenceReached(AS_OPEN_COMMENT))
+ {
+ isInComment = true;
+ if (shouldPadOperators)
+ appendSpacePad();
+ appendSequence(AS_OPEN_COMMENT);
+ goForward(1);
+ continue;
+ }
+ else if (currentChar == '"' || currentChar == '\'')
+ {
+ isInQuote = true;
+ quoteChar = currentChar;
+ //// if (shouldPadOperators) // BUGFIX: these two lines removed. seem to be unneeded, and interfere with L"
+ //// appendSpacePad(); // BUFFIX: TODO make sure the removal of these lines doesn't reopen old bugs...
+ appendCurrentChar();
+ continue;
+ }
+
+ /* not in quote or comment or white-space of any type ... */
+
+
+ // check if in preprocessor
+ // ** isInPreprocessor will be automatically reset at the begining
+ // of a new line in getnextChar()
+ if (currentChar == '#')
+ isInPreprocessor = true;
+
+ if (isInPreprocessor)
+ {
+ appendCurrentChar();
+ continue;
+ }
+
+ /* not in preprocessor ... */
+
+ if (isImmediatelyPostComment)
+ {
+ isImmediatelyPostComment = false;
+ isCharImmediatelyPostComment = true;
+ }
+
+ if (isImmediatelyPostLineComment)
+ {
+ isImmediatelyPostLineComment = false;
+ isCharImmediatelyPostLineComment = true;
+ }
+
+ if (shouldBreakLineAfterComments)
+ {
+ shouldBreakLineAfterComments = false;
+ shouldReparseCurrentChar = true;
+ breakLine();
+ continue;
+ }
+
+ // reset isImmediatelyPostHeader information
+ if (isImmediatelyPostHeader)
+ {
+ isImmediatelyPostHeader = false;
+ isCharImmediatelyPostHeader = true;
+
+ // Make sure headers are broken from their succeeding blocks
+ // (e.g.
+ // if (isFoo) DoBar();
+ // should become
+ // if (isFoo)
+ // DoBar;
+ // )
+ // But treat else if() as a special case which should not be broken!
+ if (shouldBreakOneLineStatements)
+ {
+ // if may break 'else if()'s, ythen simply break the line
+
+ if (shouldBreakElseIfs)
+ isInLineBreak = true;
+
+ else
+ {
+ // make sure 'else if()'s are not broken.
+
+ bool isInElseIf = false;
+ const string *upcomingHeader;
+
+ upcomingHeader = findHeader(headers);
+ if (currentHeader == &AS_ELSE && upcomingHeader == &AS_IF)
+ isInElseIf = true;
+
+ if (!isInElseIf)
+ isInLineBreak = true; ////BUGFIX: SHOULD NOT BE breakLine() !!!
+ }
+ }
+ }
+
+ if (passedSemicolon)
+ {
+ passedSemicolon = false;
+ if (parenStack->back() == 0)
+ {
+ shouldReparseCurrentChar = true;
+ isInLineBreak = true;
+ continue;
+ }
+ }
+
+ if (passedColon)
+ {
+ passedColon = false;
+ if (parenStack->back() == 0)
+ {
+ shouldReparseCurrentChar = true;
+ isInLineBreak = true;
+ continue;
+ }
+ }
+
+ // Check if in template declaration, e.g. foo<bar> or foo<bar,fig>
+ // If so, set isInTemplate to true
+ //
+ if (!isInTemplate && currentChar == '<')
+ {
+ int templateDepth = 0;
+ const string *oper;
+ for (unsigned int i=charNum;
+ i< currentLine.length();
+ i += (oper ? oper->length() : 1) )
+ {
+ oper = ASBeautifier::findHeader(currentLine, i, operators);
+
+ if (oper == &AS_LS)
+ {
+ templateDepth++;
+ }
+ else if (oper == &AS_GR)
+ {
+ templateDepth--;
+ if (templateDepth == 0)
+ {
+ // this is a template!
+ //
+ isInTemplate = true;
+ break;
+ }
+ }
+ else if (oper == &AS_COMMA // comma, e.g. A<int, char>
+ || oper == &AS_BIT_AND // reference, e.g. A<int&>
+ || oper == &AS_MULT // pointer, e.g. A<int*>
+ || oper == &AS_COLON_COLON) // ::, e.g. std::string
+ {
+ continue;
+ }
+ else if (!isLegalNameChar(currentLine[i]) && !isWhiteSpace(currentLine[i]))
+ {
+ // this is not a template -> leave...
+ //
+ isInTemplate = false;
+ break;
+ }
+ }
+ }
+
+
+ // handle parenthesies
+ //
+ if (currentChar == '(' || currentChar == '[' || (isInTemplate && currentChar == '<'))
+ {
+ parenStack->back()++;
+ }
+ else if (currentChar == ')' || currentChar == ']' || (isInTemplate && currentChar == '>'))
+ {
+ parenStack->back()--;
+ if (isInTemplate && parenStack->back() == 0)
+ {
+ isInTemplate = false;
+ isCharImmediatelyPostTemplate = true;
+ }
+
+ // check if this parenthesis closes a header, e.g. if (...), while (...)
+ //
+ if (isInHeader && parenStack->back() == 0)
+ {
+ isInHeader = false;
+ isImmediatelyPostHeader = true;
+ }
+
+ }
+
+ // handle brackets
+ //
+ BracketType bracketType = NULL_TYPE;
+
+ if (currentChar == '{')
+ {
+ bracketType = getBracketType();
+ foundPreDefinitionHeader = false;
+ foundPreCommandHeader = false;
+
+ bracketTypeStack->push_back(bracketType);
+ preBracketHeaderStack->push_back(currentHeader);
+ currentHeader = NULL;
+
+ isPreviousBracketBlockRelated = !IS_A(bracketType, ARRAY_TYPE);
+ }
+ else if (currentChar == '}')
+ {
+ // if a request has been made to append a post block empty line,
+ // but the block exists immediately before a closing bracket,
+ // then there is not need for the post block empty line.
+ //
+ isAppendPostBlockEmptyLineRequested = false;
+
+ if (!bracketTypeStack->empty())
+ {
+ bracketType = bracketTypeStack->back();
+ bracketTypeStack->pop_back();
+
+ isPreviousBracketBlockRelated = !IS_A(bracketType, ARRAY_TYPE);
+ }
+
+ if (!preBracketHeaderStack->empty())
+ {
+ currentHeader = preBracketHeaderStack->back();
+ preBracketHeaderStack->pop_back();
+ }
+ else
+ currentHeader = NULL;
+ }
+
+ if (!IS_A(bracketType, ARRAY_TYPE))
+ {
+
+ if (currentChar == '{')
+ {
+ parenStack->push_back(0);
+ }
+ else if (currentChar == '}')
+ {
+ if (!parenStack->empty())
+ {
+ parenStack->pop_back();
+ }
+ }
+
+ if (bracketFormatMode != NONE_MODE)
+ {
+ if (currentChar == '{')
+ {
+ if ( ( bracketFormatMode == ATTACH_MODE
+ || bracketFormatMode == BDAC_MODE && bracketTypeStack->size()>=2
+ && IS_A((*bracketTypeStack)[bracketTypeStack->size()-2], COMMAND_TYPE) /*&& isInLineBreak*/)
+ && !isCharImmediatelyPostLineComment )
+ {
+ appendSpacePad();
+ if (!isCharImmediatelyPostComment // do not attach '{' to lines that end with /**/ comments.
+ && previousCommandChar != '{'
+ && previousCommandChar != '}'
+ && previousCommandChar != ';') // '}' , ';' chars added for proper handling of '{' immediately after a '}' or ';'
+ appendCurrentChar(false);
+ else
+ appendCurrentChar(true);
+ continue;
+ }
+ else if (bracketFormatMode == BREAK_MODE
+ || bracketFormatMode == BDAC_MODE && bracketTypeStack->size()>=2
+ && IS_A((*bracketTypeStack)[bracketTypeStack->size()-2], DEFINITION_TYPE))
+ {
+ if ( shouldBreakOneLineBlocks || !IS_A(bracketType, SINGLE_LINE_TYPE) )
+ breakLine();
+ appendCurrentChar();
+ continue;
+ }
+ }
+ else if (currentChar == '}')
+ {
+ // bool origLineBreak = isInLineBreak;
+
+ // mark state of immediately after empty block
+ // this state will be used for locating brackets that appear immedately AFTER an empty block (e.g. '{} \n}').
+ if (previousCommandChar == '{')
+ isImmediatelyPostEmptyBlock = true;
+
+ if ( (!(previousCommandChar == '{' && isPreviousBracketBlockRelated) ) // this '{' does not close an empty block
+ && (shouldBreakOneLineBlocks || !IS_A(bracketType, SINGLE_LINE_TYPE)) // astyle is allowed to break on line blocks
+ && !isImmediatelyPostEmptyBlock) // this '}' does not immediately follow an empty block
+ {
+ breakLine();
+ appendCurrentChar();
+ }
+ else
+ {
+ // Content Patch ASFormatter.cpp.patch.bz2
+ // if (!isCharImmediatelyPostComment)
+ if (!isCharImmediatelyPostComment &&
+ !isCharImmediatelyPostLineComment)
+ isInLineBreak = false;
+ appendCurrentChar();
+ if (shouldBreakOneLineBlocks || !IS_A(bracketType, SINGLE_LINE_TYPE))
+ shouldBreakLineAfterComments = true;
+ }
+
+ if (shouldBreakBlocks)
+ {
+ isAppendPostBlockEmptyLineRequested =true;
+ }
+
+ continue;
+ }
+ }
+ }
+
+ if ( ( (previousCommandChar == '{'
+ && isPreviousBracketBlockRelated)
+
+ || (previousCommandChar == '}'
+ && !isImmediatelyPostEmptyBlock // <--
+ && isPreviousBracketBlockRelated
+ && !isPreviousCharPostComment // <-- Fixes wrongly appended newlines after '}' immediately after comments... 10/9/1999
+ && peekNextChar() != ' '))
+
+ && (shouldBreakOneLineBlocks || !IS_A(bracketTypeStack->back(), SINGLE_LINE_TYPE)) )
+ {
+ isCharImmediatelyPostOpenBlock = (previousCommandChar == '{');
+ isCharImmediatelyPostCloseBlock = (previousCommandChar == '}');
+
+ previousCommandChar = ' ';
+ isInLineBreak = true; //<----
+ }
+
+ // reset block handling flags
+ isImmediatelyPostEmptyBlock = false;
+
+ // look for headers
+ if (!isInTemplate)
+ {
+ if ( (newHeader = findHeader(headers)) != NULL)
+ {
+ foundClosingHeader = false;
+ const string *previousHeader;
+
+ // recognize closing headers of do..while, if..else, try..catch..finally
+ if ( (newHeader == &AS_ELSE && currentHeader == &AS_IF)
+ || (newHeader == &AS_WHILE && currentHeader == &AS_DO)
+ || (newHeader == &AS_CATCH && currentHeader == &AS_TRY)
+ || (newHeader == &AS_CATCH && currentHeader == &AS_CATCH)
+ || (newHeader == &AS_FINALLY && currentHeader == &AS_TRY)
+ || (newHeader == &AS_FINALLY && currentHeader == &AS_CATCH) )
+ foundClosingHeader = true;
+
+ previousHeader = currentHeader;
+ currentHeader = newHeader;
+
+ // If in ATTACH or LINUX bracket modes, attach closing headers (e.g. 'else', 'catch')
+ // to their preceding bracket,
+ // But do not perform the attachment if the shouldBreakClosingHeaderBrackets is set!
+ if (!shouldBreakClosingHeaderBrackets && foundClosingHeader && (bracketFormatMode == ATTACH_MODE || bracketFormatMode == BDAC_MODE) && previousNonWSChar == '}')
+ {
+ isInLineBreak = false;
+ appendSpacePad();
+
+ if (shouldBreakBlocks)
+ isAppendPostBlockEmptyLineRequested = false;
+ }
+
+ //Check if a template definition as been reached, e.g. template<class A>
+ if (newHeader == &AS_TEMPLATE)
+ {
+ isInTemplate = true;
+ }
+
+ // check if the found header is non-paren header
+ isNonParenHeader = ( find(nonParenHeaders.begin(), nonParenHeaders.end(),
+ newHeader) != nonParenHeaders.end() );
+ appendSequence(*currentHeader);
+ goForward(currentHeader->length() - 1);
+ // if padding is on, and a paren-header is found
+ // then add a space pad after it.
+ if (shouldPadOperators && !isNonParenHeader)
+ appendSpacePad();
+
+
+ // Signal that a header has been reached
+ // *** But treat a closing while() (as in do...while)
+ // as if it where NOT a header since a closing while()
+ // should never have a block after it!
+ if (!(foundClosingHeader && currentHeader == &AS_WHILE))
+ {
+ isInHeader = true;
+ if (isNonParenHeader)
+ {
+ isImmediatelyPostHeader = true;
+ isInHeader = false;
+ }
+ }
+
+ if (currentHeader == &AS_IF && previousHeader == &AS_ELSE)
+ isInLineBreak = false;
+
+ if (shouldBreakBlocks)
+ {
+ if (previousHeader == NULL
+ && !foundClosingHeader
+ && !isCharImmediatelyPostOpenBlock)
+ {
+ isPrependPostBlockEmptyLineRequested = true;
+ }
+
+ if (currentHeader == &AS_ELSE
+ || currentHeader == &AS_CATCH
+ || currentHeader == &AS_FINALLY
+ || foundClosingHeader)
+ {
+ isPrependPostBlockEmptyLineRequested = false;
+ }
+
+ if (shouldBreakClosingHeaderBlocks
+ && isCharImmediatelyPostCloseBlock)
+ {
+ isPrependPostBlockEmptyLineRequested = true;
+ }
+
+ }
+
+ continue;
+ }
+ else if ( (newHeader = findHeader(preDefinitionHeaders)) != NULL)
+ {
+ foundPreDefinitionHeader = true;
+ appendSequence(*newHeader);
+ goForward(newHeader->length() - 1);
+
+ if (shouldBreakBlocks)
+ isPrependPostBlockEmptyLineRequested = true;
+
+ continue;
+ }
+ else if ( (newHeader = findHeader(preCommandHeaders)) != NULL)
+ {
+ foundPreCommandHeader = true;
+ appendSequence(*newHeader);
+ goForward(newHeader->length() - 1);
+
+ continue;
+ }
+ }
+
+ if (previousNonWSChar == '}' || currentChar == ';')
+ {
+ if (shouldBreakOneLineStatements && currentChar == ';'
+ && (shouldBreakOneLineBlocks || !IS_A(bracketTypeStack->back(), SINGLE_LINE_TYPE)))
+ {
+ passedSemicolon = true;
+ }
+
+ if (shouldBreakBlocks && currentHeader != NULL && parenStack->back() == 0)
+ {
+ isAppendPostBlockEmptyLineRequested = true;
+ }
+
+ if (currentChar != ';')
+ currentHeader = NULL; //DEVEL: is this ok?
+
+ foundQuestionMark = false;
+ foundPreDefinitionHeader = false;
+ foundPreCommandHeader = false;
+ isInPotentialCalculation = false;
+
+ }
+
+ if (currentChar == ':'
+ && shouldBreakOneLineStatements
+ && !foundQuestionMark // not in a ... ? ... : ... sequence
+ && !foundPreDefinitionHeader // not in a definition block (e.g. class foo : public bar
+ && previousCommandChar != ')' // not immediately after closing paren of a method header, e.g. ASFormatter::ASFormatter(...) : ASBeautifier(...)
+ && previousChar != ':' // not part of '::'
+ && peekNextChar() != ':') // not part of '::'
+ {
+ passedColon = true;
+ if (shouldBreakBlocks)
+ isPrependPostBlockEmptyLineRequested = true;
+ }
+
+ if (currentChar == '?')
+ foundQuestionMark = true;
+
+ if (shouldPadOperators)
+ {
+ if ((newHeader = findHeader(operators)) != NULL)
+ {
+ bool shouldPad = (newHeader != &AS_COLON_COLON
+ && newHeader != &AS_PAREN_PAREN
+ && newHeader != &AS_BLPAREN_BLPAREN
+ && newHeader != &AS_PLUS_PLUS
+ && newHeader != &AS_MINUS_MINUS
+ && newHeader != &AS_NOT
+ && newHeader != &AS_BIT_NOT
+ && newHeader != &AS_ARROW
+ && newHeader != &AS_OPERATOR
+ && !(newHeader == &AS_MINUS && isInExponent())
+ && !(newHeader == &AS_PLUS && isInExponent())
+ && previousOperator != &AS_OPERATOR
+ && !((newHeader == &AS_MULT || newHeader == &AS_BIT_AND)
+ && isPointerOrReference())
+ && !( (isInTemplate || isCharImmediatelyPostTemplate)
+ && (newHeader == &AS_LS || newHeader == &AS_GR))
+ );
+
+ if (!isInPotentialCalculation)
+ if (find(assignmentOperators.begin(), assignmentOperators.end(), newHeader)
+ != assignmentOperators.end())
+ isInPotentialCalculation = true;
+
+ // pad before operator
+ if (shouldPad
+ && !(newHeader == &AS_COLON && !foundQuestionMark)
+ && newHeader != &AS_SEMICOLON
+ && newHeader != &AS_COMMA)
+ appendSpacePad();
+ appendSequence(*newHeader);
+ goForward(newHeader->length() - 1);
+
+ // since this block handles '()' and '[]',
+ // the parenStack must be updated here accordingly!
+ if (newHeader == &AS_PAREN_PAREN
+ || newHeader == &AS_BLPAREN_BLPAREN)
+ parenStack->back()--;
+
+ currentChar = (*newHeader)[newHeader->length() - 1];
+ // pad after operator
+ // but do not pad after a '-' that is a urinary-minus.
+ if ( shouldPad && !(newHeader == &AS_MINUS && isUrinaryMinus()) )
+ appendSpacePad();
+
+ previousOperator = newHeader;
+ continue;
+ }
+ }
+ //BEGIN Content Patch patch1_ssvb_patch.tar.gz
+ if (currentChar == '(' || currentChar == '[' )
+ isInPotentialCalculation = true;
+ //END Content Patch patch1_ssvb_patch.tar.gz
+ if (shouldPadParenthesies)
+ {
+ if (currentChar == '(' || currentChar == '[' )
+ {
+ char peekedChar = peekNextChar();
+
+ isInPotentialCalculation = true;
+ appendCurrentChar();
+ if (!(currentChar == '(' && peekedChar == ')')
+ && !(currentChar == '[' && peekedChar == ']'))
+ appendSpacePad();
+ continue;
+ }
+ else if (currentChar == ')' || currentChar == ']')
+ {
+ char peekedChar = peekNextChar();
+
+ if (!(previousChar == '(' && currentChar == ')')
+ && !(previousChar == '[' && currentChar == ']'))
+ appendSpacePad();
+
+ appendCurrentChar();
+
+ if (peekedChar != ';' && peekedChar != ',' && peekedChar != '.'
+ && !(currentChar == ']' && peekedChar == '['))
+ appendSpacePad();
+ continue;
+ }
+ }
+
+ appendCurrentChar();
+ }
+
+ // return a beautified (i.e. correctly indented) line.
+
+ string beautifiedLine;
+ int readyFormattedLineLength = trim(readyFormattedLine).length();
+
+ if (prependEmptyLine
+ && readyFormattedLineLength > 0
+ && previousReadyFormattedLineLength > 0)
+ {
+ isLineReady = true; // signal that a readyFormattedLine is still waiting
+ beautifiedLine = beautify("");
+ }
+ else
+ {
+ isLineReady = false;
+ beautifiedLine = beautify(readyFormattedLine);
+ }
+
+ prependEmptyLine = false;
+ previousReadyFormattedLineLength = readyFormattedLineLength;
+
+ return beautifiedLine;
+
+ }
+
+
+ /**
+ * check if there are any indented lines ready to be read by nextLine()
+ *
+ * @return are there any indented lines ready?
+ */
+ bool ASFormatter::hasMoreLines() const
+ {
+ if (!isFormattingEnabled())
+ return ASBeautifier::hasMoreLines();
+ else
+ return !endOfCodeReached;
+ }
+
+ /**
+ * check if formatting options are enabled, in addition to indentation.
+ *
+ * @return are formatting options enabled?
+ */
+ bool ASFormatter::isFormattingEnabled() const
+ {
+ return (bracketFormatMode != NONE_MODE
+ || shouldPadOperators
+ || shouldConvertTabs);
+ }
+
+ /**
+ * set the bracket formatting mode.
+ * options:
+ * astyle::NONE_MODE no formatting of brackets.
+ * astyle::ATTACH_MODE Java, K&R style bracket placement.
+ * astyle::BREAK_MODE ANSI C/C++ style bracket placement.
+ *
+ * @param mode the bracket formatting mode.
+ */
+ void ASFormatter::setBracketFormatMode(BracketMode mode)
+ {
+ bracketFormatMode = mode;
+ }
+
+ /**
+ * set closing header bracket breaking mode
+ * options:
+ * true brackets just before closing headers (e.g. 'else', 'catch')
+ * will be broken, even if standard brackets are attached.
+ * false closing header brackets will be treated as standard brackets.
+ *
+ * @param mode the closing header bracket breaking mode.
+ */
+ void ASFormatter::setBreakClosingHeaderBracketsMode(bool state)
+ {
+ shouldBreakClosingHeaderBrackets = state;
+ }
+
+ /**
+ * set 'else if()' breaking mode
+ * options:
+ * true 'else' headers will be broken from their succeeding 'if' headers.
+ * false 'else' headers will be attached to their succeeding 'if' headers.
+ *
+ * @param mode the 'else if()' breaking mode.
+ */
+ void ASFormatter::setBreakElseIfsMode(bool state)
+ {
+ shouldBreakElseIfs = state;
+ }
+
+ /**
+ * set operator padding mode.
+ * options:
+ * true statement operators will be padded with spaces around them.
+ * false statement operators will not be padded.
+ *
+ * @param mode the padding mode.
+ */
+ void ASFormatter::setOperatorPaddingMode(bool state)
+ {
+ shouldPadOperators = state;
+ }
+
+ /**
+ * set parentheies padding mode.
+ * options:
+ * true statement parenthesies will be padded with spaces around them.
+ * false statement parenthesies will not be padded.
+ *
+ * @param mode the padding mode.
+ */
+ void ASFormatter::setParenthesisPaddingMode(bool state)
+ {
+ shouldPadParenthesies = state;
+ }
+
+ /**
+ * set option to break/not break one-line blocks
+ *
+ * @param state true = break, false = don't break.
+ */
+ void ASFormatter::setBreakOneLineBlocksMode(bool state)
+ {
+ shouldBreakOneLineBlocks = state;
+ }
+
+ /**
+ * set option to break/not break lines consisting of multiple statements.
+ *
+ * @param state true = break, false = don't break.
+ */
+ void ASFormatter::setSingleStatementsMode(bool state)
+ {
+ shouldBreakOneLineStatements = state;
+ }
+
+ /**
+ * set option to convert tabs to spaces.
+ *
+ * @param state true = convert, false = don't convert.
+ */
+ void ASFormatter::setTabSpaceConversionMode(bool state)
+ {
+ shouldConvertTabs = state;
+ }
+
+
+ /**
+ * set option to break unrelated blocks of code with empty lines.
+ *
+ * @param state true = convert, false = don't convert.
+ */
+ void ASFormatter::setBreakBlocksMode(bool state)
+ {
+ shouldBreakBlocks = state;
+ }
+
+ /**
+ * set option to break closing header blocks of code (such as 'else', 'catch', ...) with empty lines.
+ *
+ * @param state true = convert, false = don't convert.
+ */
+ void ASFormatter::setBreakClosingHeaderBlocksMode(bool state)
+ {
+ shouldBreakClosingHeaderBlocks = state;
+ }
+
+ /**
+ * check if a specific sequence exists in the current placement of the current line
+ *
+ * @return whether sequence has been reached.
+ * @param sequence the sequence to be checked
+ */
+ bool ASFormatter::isSequenceReached(const string &sequence) const
+ {
+ return currentLine.COMPARE(charNum, sequence.length(), sequence) == 0;
+
+ }
+
+ /**
+ * jump over several characters.
+ *
+ * @param i the number of characters to jump over.
+ */
+ void ASFormatter::goForward(int i)
+ {
+ while (--i >= 0)
+ getNextChar();
+ }
+
+ /**
+ * peek at the next unread character.
+ *
+ * @return the next unread character.
+ */
+ char ASFormatter::peekNextChar() const
+ {
+ int peekNum = charNum + 1;
+ int len = currentLine.length();
+ char ch = ' ';
+
+ while (peekNum < len)
+ {
+ ch = currentLine[peekNum++];
+ if (!isWhiteSpace(ch))
+ return ch;
+ }
+
+ if (shouldConvertTabs && ch == '\t')
+ ch = ' ';
+
+ return ch;
+ }
+
+ /**
+ * check if current placement is before a comment or line-comment
+ *
+ * @return is before a comment or line-comment.
+ */
+ bool ASFormatter::isBeforeComment() const
+ {
+ int peekNum = charNum + 1;
+ int len = currentLine.length();
+ // char ch = ' ';
+ bool foundComment = false;
+
+ for (peekNum = charNum + 1;
+ peekNum < len && isWhiteSpace(currentLine[peekNum]);
+ ++peekNum)
+ ;
+
+ if (peekNum < len)
+ foundComment = ( currentLine.COMPARE(peekNum, 2, AS_OPEN_COMMENT) == 0
+ || currentLine.COMPARE(peekNum, 2, AS_OPEN_LINE_COMMENT) == 0 );
+
+ return foundComment;
+ }
+
+ /**
+ * get the next character, increasing the current placement in the process.
+ * the new character is inserted into the variable currentChar.
+ *
+ * @return whether succeded to recieve the new character.
+ */
+ bool ASFormatter::getNextChar()
+ {
+ isInLineBreak = false;
+ bool isAfterFormattedWhiteSpace = false;
+
+ if (shouldPadOperators && !isInComment && !isInLineComment
+ && !isInQuote && !doesLineStartComment && !isInPreprocessor
+ && !isBeforeComment())
+ {
+ //BEGIN Content Patch patch1_ssvb_patch.tar.gz
+ char prevchar = ' ';
+ char nextchar = peekNextChar();
+
+ int len = formattedLine.length();
+ // if (len > 0 && isWhiteSpace(formattedLine[len-1]))
+ if (len > 0) prevchar = formattedLine[len-1];
+ if (isWhiteSpace(prevchar) || prevchar == '(' || prevchar == '[' ||
+ nextchar == ')' || nextchar == ']')
+ {
+ isAfterFormattedWhiteSpace = true;
+ }
+ //END Content Patch patch1_ssvb_patch.tar.gz
+ }
+
+ previousChar = currentChar;
+ if (!isWhiteSpace(currentChar))
+ {
+ previousNonWSChar = currentChar;
+ if (!isInComment && !isInLineComment && !isInQuote
+ && !isSequenceReached(AS_OPEN_COMMENT)
+ && !isSequenceReached(AS_OPEN_LINE_COMMENT) )
+ previousCommandChar = previousNonWSChar;
+ }
+
+ unsigned int currentLineLength = currentLine.length();
+
+ if (charNum+1 < currentLineLength
+ && (!isWhiteSpace(peekNextChar()) || isInComment || isInLineComment))
+ {
+ currentChar = currentLine[++charNum];
+ if (isAfterFormattedWhiteSpace)
+ while (isWhiteSpace(currentChar) && charNum+1 < currentLineLength)
+ currentChar = currentLine[++charNum];
+
+ if (shouldConvertTabs && currentChar == '\t')
+ currentChar = ' ';
+
+ return true;
+ }
+ // BEGIN Content patch ASFormatter450670.patch.bz2
+ else if (isInLineComment && (charNum+1 == currentLineLength))
+ {
+ // fix BUG #450670
+ currentChar = ' ';
+ return true;
+ }
+ // END Content patch ASFormatter450670.patch.bz2
+ else
+ {
+ if (sourceIterator->hasMoreLines())
+ {
+ currentLine = sourceIterator->nextLine();
+ if (currentLine.length() == 0)
+ {
+ /*think*/ currentLine = string(" ");
+ }
+
+ // unless reading in the first line of the file,
+ // break a new line.
+ if (!isVirgin)
+ isInLineBreak = true;
+ else
+ isVirgin = false;
+
+ if (isInLineComment)
+ isImmediatelyPostLineComment = true;
+ isInLineComment = false;
+
+ trimNewLine();
+ currentChar = currentLine[charNum];
+
+ // check if is in preprocessor right after the line break and line trimming
+ if (previousNonWSChar != '\\')
+ isInPreprocessor = false;
+
+ if (shouldConvertTabs && currentChar == '\t')
+ currentChar = ' ';
+
+ return true;
+ }
+ else
+ {
+ endOfCodeReached = true;
+ return false;
+ }
+ }
+ }
+
+ /**
+ * jump over the leading white space in the current line,
+ * IF the line does not begin a comment or is in a preprocessor definition.
+ */
+ void ASFormatter::trimNewLine()
+ {
+ unsigned int len = currentLine.length();
+ charNum = 0;
+
+ if (isInComment || isInPreprocessor)
+ return;
+
+ while (isWhiteSpace(currentLine[charNum]) && charNum+1 < len)
+ ++charNum;
+
+ doesLineStartComment = false;
+ if (isSequenceReached(string("/*")))
+ {
+ charNum = 0;
+ doesLineStartComment = true;
+ }
+ }
+
+ /**
+ * append a character to the current formatted line.
+ * Unless disabled (via canBreakLine == false), first check if a
+ * line-break has been registered, and if so break the
+ * formatted line, and only then append the character into
+ * the next formatted line.
+ *
+ * @param ch the character to append.
+ * @param canBreakLine if true, a registered line-break
+ */
+ void ASFormatter::appendChar(char ch, bool canBreakLine)
+ {
+ if (canBreakLine && isInLineBreak)
+ breakLine();
+ formattedLine.append(1, ch);
+ }
+
+ /**
+ * append the CURRENT character (curentChar)to the current
+ * formatted line. Unless disabled (via canBreakLine == false),
+ * first check if a line-break has been registered, and if so
+ * break the formatted line, and only then append the character
+ * into the next formatted line.
+ *
+ * @param canBreakLine if true, a registered line-break
+ */
+ void ASFormatter::appendCurrentChar(bool canBreakLine)
+ {
+ appendChar(currentChar, canBreakLine);
+ }
+
+ /**
+ * append a string sequence to the current formatted line.
+ * Unless disabled (via canBreakLine == false), first check if a
+ * line-break has been registered, and if so break the
+ * formatted line, and only then append the sequence into
+ * the next formatted line.
+ *
+ * @param sequence the sequence to append.
+ * @param canBreakLine if true, a registered line-break
+ */
+ void ASFormatter::appendSequence(const string &sequence, bool canBreakLine)
+ {
+ if (canBreakLine && isInLineBreak)
+ breakLine();
+ formattedLine.append(sequence);
+ }
+
+ /**
+ * append a space to the current formattedline, UNLESS the
+ * last character is already a white-space character.
+ */
+ void ASFormatter::appendSpacePad()
+ {
+ int len = formattedLine.length();
+ if (len == 0 || !isWhiteSpace(formattedLine[len-1]))
+ formattedLine.append(1, ' ');
+ }
+
+ /**
+ * register a line break for the formatted line.
+ */
+ void ASFormatter::breakLine()
+ {
+ isLineReady = true;
+ isInLineBreak = false;
+
+ // queue an empty line prepend request if one exists
+ prependEmptyLine = isPrependPostBlockEmptyLineRequested;
+
+ readyFormattedLine = formattedLine;
+ if (isAppendPostBlockEmptyLineRequested)
+ {
+ isAppendPostBlockEmptyLineRequested = false;
+ isPrependPostBlockEmptyLineRequested = true;
+ }
+ else
+ {
+ isPrependPostBlockEmptyLineRequested = false;
+ }
+
+ formattedLine = "";
+ }
+
+ /**
+ * check if the currently reached open-bracket (i.e. '{')
+ * opens a:
+ * - a definition type block (such as a class or namespace),
+ * - a command block (such as a method block)
+ * - a static array
+ * this method takes for granted that the current character
+ * is an opening bracket.
+ *
+ * @return the type of the opened block.
+ */
+ BracketType ASFormatter::getBracketType() const
+ {
+ BracketType returnVal;
+
+ if (foundPreDefinitionHeader)
+ returnVal = DEFINITION_TYPE;
+ else
+ {
+ bool isCommandType;
+ isCommandType = ( foundPreCommandHeader
+ || ( currentHeader != NULL && isNonParenHeader )
+ || ( previousCommandChar == ')' )
+ || ( previousCommandChar == ':' && !foundQuestionMark )
+ || ( previousCommandChar == ';' )
+ || ( ( previousCommandChar == '{' || previousCommandChar == '}')
+ && isPreviousBracketBlockRelated ) );
+
+ returnVal = (isCommandType ? COMMAND_TYPE : ARRAY_TYPE);
+ }
+
+ if (isOneLineBlockReached())
+ returnVal = (BracketType) (returnVal | SINGLE_LINE_TYPE);
+
+ return returnVal;
+ }
+
+ /**
+ * check if the currently reached '*' or '&' character is
+ * a pointer-or-reference symbol, or another operator.
+ * this method takes for granted that the current character
+ * is either a '*' or '&'.
+ *
+ * @return whether current character is a reference-or-pointer
+ */
+ bool ASFormatter::isPointerOrReference() const
+ {
+ bool isPR;
+ isPR = ( !isInPotentialCalculation
+ || IS_A(bracketTypeStack->back(), DEFINITION_TYPE)
+ || (!isLegalNameChar(previousNonWSChar)
+ && previousNonWSChar != ')'
+ && previousNonWSChar != ']')
+ );
+
+ if (!isPR)
+ {
+ char nextChar = peekNextChar();
+ isPR |= (!isWhiteSpace(nextChar)
+ && nextChar != '-'
+ && nextChar != '('
+ && nextChar != '['
+ && !isLegalNameChar(nextChar));
+ }
+
+ return isPR;
+ }
+
+
+ /**
+ * check if the currently reached '-' character is
+ * a urinary minus
+ * this method takes for granted that the current character
+ * is a '-'.
+ *
+ * @return whether the current '-' is a urinary minus.
+ */
+ bool ASFormatter::isUrinaryMinus() const
+ {
+ return ( (previousOperator == &AS_RETURN || !isalnum(previousCommandChar))
+ && previousCommandChar != '.'
+ && previousCommandChar != ')'
+ && previousCommandChar != ']' );
+ }
+
+
+ /**
+ * check if the currently reached '-' or '+' character is
+ * part of an exponent, i.e. 0.2E-5.
+ * this method takes for granted that the current character
+ * is a '-' or '+'.
+ *
+ * @return whether the current '-' is in an exponent.
+ */
+ bool ASFormatter::isInExponent() const
+ {
+ int formattedLineLength = formattedLine.length();
+ if (formattedLineLength >= 2)
+ {
+ char prevPrevFormattedChar = formattedLine[formattedLineLength - 2];
+ char prevFormattedChar = formattedLine[formattedLineLength - 1];
+
+ return ( (prevFormattedChar == 'e' || prevFormattedChar == 'E')
+ && (prevPrevFormattedChar == '.' || isdigit(prevPrevFormattedChar)) );
+ }
+ else
+ return false;
+ }
+
+ /**
+ * check if a one-line bracket has been reached,
+ * i.e. if the currently reached '{' character is closed
+ * with a complimentry '}' elsewhere on the current line,
+ *.
+ * @return has a one-line bracket been reached?
+ */
+ bool ASFormatter::isOneLineBlockReached() const
+ {
+ bool isInComment = false;
+ bool isInQuote = false;
+ int bracketCount = 1;
+ int currentLineLength = currentLine.length();
+ int i = 0;
+ char ch = ' ';
+ char quoteChar = ' ';
+
+ for (i = charNum + 1; i < currentLineLength; ++i)
+ {
+ ch = currentLine[i];
+
+ if (isInComment)
+ {
+ if (currentLine.COMPARE(i, 2, "*/") == 0)
+ {
+ isInComment = false;
+ ++i;
+ }
+ continue;
+ }
+
+ if (ch == '\\')
+ {
+ ++i;
+ continue;
+ }
+
+ if (isInQuote)
+ {
+ if (ch == quoteChar)
+ isInQuote = false;
+ continue;
+ }
+
+ if (ch == '"' || ch == '\'')
+ {
+ isInQuote = true;
+ quoteChar = ch;
+ continue;
+ }
+
+ if (currentLine.COMPARE(i, 2, "//") == 0)
+ break;
+
+ if (currentLine.COMPARE(i, 2, "/*") == 0)
+ {
+ isInComment = true;
+ ++i;
+ continue;
+ }
+
+ if (ch == '{')
+ ++bracketCount;
+ else if (ch == '}')
+ --bracketCount;
+
+ if(bracketCount == 0)
+ return true;
+ }
+
+ return false;
+ }
+
+
+ /**
+ * check if one of a set of headers has been reached in the
+ * current position of the current line.
+ *
+ * @return a pointer to the found header. Or a NULL if no header has been reached.
+ * @param headers a vector of headers
+ * @param checkBoundry
+ */
+ const string *ASFormatter::findHeader(const vector<const string*> &headers, bool checkBoundry)
+ {
+ return ASBeautifier::findHeader(currentLine, charNum, headers, checkBoundry);
+ }
+
+
+
+#ifdef USES_NAMESPACE
+}
+#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.
+ */
+
+
+#ifndef ASFORMATTER_H
+#define ASFORMATTER_H
+
+#include "ASBeautifier.h"
+//#include "enums.h"
+#include "compiler_defines.h"
+
+namespace astyle {
+
+ class ASFormatter : public ASBeautifier
+ {
+ public:
+ ASFormatter();
+ virtual ~ASFormatter();
+ virtual void init(ASSourceIterator* iter);
+ virtual bool hasMoreLines() const;
+ virtual string nextLine();
+ void setBracketFormatMode(BracketMode mode);
+ void setBreakClosingHeaderBracketsMode(bool state);
+ void setOperatorPaddingMode(bool mode);
+ void setParenthesisPaddingMode(bool mode);
+ void setBreakOneLineBlocksMode(bool state);
+ void setSingleStatementsMode(bool state);
+ void setTabSpaceConversionMode(bool state);
+ void setBreakBlocksMode(bool state);
+ void setBreakClosingHeaderBlocksMode(bool state);
+ void setBreakElseIfsMode(bool state);
+
+ private:
+ void ASformatter(ASFormatter &copy); // not to be imlpemented
+ void operator=(ASFormatter&); // not to be implemented
+ void staticInit();
+ bool isFormattingEnabled() const;
+ void goForward(int i);
+ bool getNextChar();
+ char peekNextChar() const;
+ bool isBeforeComment() const;
+ void trimNewLine();
+ BracketType getBracketType() const;
+ bool isPointerOrReference() const;
+ bool isUrinaryMinus() const;
+ bool isInExponent() const;
+ bool isOneLineBlockReached() const;
+ void appendChar(char ch, bool canBreakLine = true);
+ void appendCurrentChar(bool canBreakLine = true);
+ void appendSequence(const string &sequence, bool canBreakLine = true);
+ void appendSpacePad();
+ void breakLine();
+ inline bool isSequenceReached(const string &sequence) const;
+ const string *findHeader(const vector<const string*> &headers, bool checkBoundry = true);
+
+ static vector<const string*> headers;
+ static vector<const string*> nonParenHeaders;
+ static vector<const string*> preprocessorHeaders;
+ static vector<const string*> preDefinitionHeaders;
+ static vector<const string*> preCommandHeaders;
+ static vector<const string*> operators;
+ static vector<const string*> assignmentOperators;
+ static bool calledInitStatic;
+
+ ASSourceIterator *sourceIterator;
+ vector<const string*> *preBracketHeaderStack;
+ vector<BracketType> *bracketTypeStack;
+ vector<int> *parenStack;
+ string readyFormattedLine;
+ string currentLine;
+ string formattedLine;
+ const string *currentHeader;
+ const string *previousOperator;
+ char currentChar;
+ char previousChar;
+ char previousNonWSChar;
+ char previousCommandChar;
+ char quoteChar;
+ unsigned int charNum;
+ BracketMode bracketFormatMode;
+ bool isVirgin;
+ bool shouldPadOperators;
+ bool shouldPadParenthesies;
+ bool shouldConvertTabs;
+ bool isInLineComment;
+ bool isInComment;
+ bool isInPreprocessor;
+ bool isInTemplate; // true both in template definitions (e.g. template<class A>) and template usage (e.g. F<int>).
+ bool doesLineStartComment;
+ bool isInQuote;
+ bool isSpecialChar;
+ bool isNonParenHeader;
+ bool foundQuestionMark;
+ bool foundPreDefinitionHeader;
+ bool foundPreCommandHeader;
+ bool isInLineBreak;
+ bool isInClosingBracketLineBreak;
+ bool endOfCodeReached;
+ bool isLineReady;
+ bool isPreviousBracketBlockRelated;
+ bool isInPotentialCalculation;
+ //bool foundOneLineBlock;
+ bool shouldBreakOneLineBlocks;
+ bool shouldReparseCurrentChar;
+ bool shouldBreakOneLineStatements;
+ bool shouldBreakLineAfterComments;
+ bool shouldBreakClosingHeaderBrackets;
+ bool shouldBreakElseIfs;
+ bool passedSemicolon;
+ bool passedColon;
+ bool isImmediatelyPostComment;
+ bool isImmediatelyPostLineComment;
+ bool isImmediatelyPostEmptyBlock;
+
+ bool shouldBreakBlocks;
+ bool shouldBreakClosingHeaderBlocks;
+ bool isPrependPostBlockEmptyLineRequested;
+ bool isAppendPostBlockEmptyLineRequested;
+
+ bool prependEmptyLine;
+ bool foundClosingHeader;
+ int previousReadyFormattedLineLength;
+
+ bool isInHeader;
+ bool isImmediatelyPostHeader;
+
+ };
+
+}
+
+#endif
+/*
+* Copyright (c) 1998,1999,2000,2001,2002 Tal Davidson. All rights reserved.
+*
+* ASResource.cpp
+* 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.
+*/
+
+#include "compiler_defines.h"
+#include "ASResource.h"
+
+#include <string>
+
+
+#ifdef USES_NAMESPACE
+using namespace std;
+
+namespace astyle
+ {
+#endif
+
+ const string ASResource::AS_IF = string("if");
+ const string ASResource::AS_ELSE = string ("else");
+ const string ASResource::AS_FOR = string("for");
+ const string ASResource::AS_DO = string("do");
+ const string ASResource::AS_WHILE = string("while");
+ const string ASResource::AS_SWITCH = string ("switch");
+ const string ASResource::AS_CASE = string ("case");
+ const string ASResource::AS_DEFAULT = string("default");
+ const string ASResource::AS_CLASS = string("class");
+ const string ASResource::AS_STRUCT = string("struct");
+ const string ASResource::AS_UNION = string("union");
+ const string ASResource::AS_INTERFACE = string("interface");
+ const string ASResource::AS_NAMESPACE = string("namespace");
+ const string ASResource::AS_EXTERN = string("extern");
+ const string ASResource::AS_PUBLIC = string("public");
+ const string ASResource::AS_PROTECTED = string("protected");
+ const string ASResource::AS_PRIVATE = string("private");
+ const string ASResource::AS_STATIC = string("static");
+ const string ASResource::AS_SYNCHRONIZED = string("synchronized");
+ const string ASResource::AS_OPERATOR = string("operator");
+ const string ASResource::AS_TEMPLATE = string("template");
+ const string ASResource::AS_TRY = string("try");
+ const string ASResource::AS_CATCH = string("catch");
+ const string ASResource::AS_FINALLY = string("finally");
+ const string ASResource::AS_THROWS = string("throws");
+ const string ASResource::AS_CONST = string("const");
+
+ const string ASResource::AS_ASM = string("asm");
+
+ const string ASResource::AS_BAR_DEFINE = string("#define");
+ const string ASResource::AS_BAR_INCLUDE = string("#include");
+ const string ASResource::AS_BAR_IF = string("#if");
+ const string ASResource::AS_BAR_EL = string("#el");
+ const string ASResource::AS_BAR_ENDIF = string("#endif");
+
+ const string ASResource::AS_OPEN_BRACKET = string("{");
+ const string ASResource::AS_CLOSE_BRACKET = string("}");
+ const string ASResource::AS_OPEN_LINE_COMMENT = string("//");
+ const string ASResource::AS_OPEN_COMMENT = string("/*");
+ const string ASResource::AS_CLOSE_COMMENT = string("*/");
+
+ const string ASResource::AS_ASSIGN = string("=");
+ const string ASResource::AS_PLUS_ASSIGN = string("+=");
+ const string ASResource::AS_MINUS_ASSIGN = string("-=");
+ const string ASResource::AS_MULT_ASSIGN = string("*=");
+ const string ASResource::AS_DIV_ASSIGN = string("/=");
+ const string ASResource::AS_MOD_ASSIGN = string("%=");
+ const string ASResource::AS_OR_ASSIGN = string("|=");
+ const string ASResource::AS_AND_ASSIGN = string("&=");
+ const string ASResource::AS_XOR_ASSIGN = string("^=");
+ const string ASResource::AS_GR_GR_ASSIGN = string(">>=");
+ const string ASResource::AS_LS_LS_ASSIGN = string("<<=");
+ const string ASResource::AS_GR_GR_GR_ASSIGN = string(">>>=");
+ const string ASResource::AS_LS_LS_LS_ASSIGN = string("<<<=");
+ const string ASResource::AS_RETURN = string("return");
+
+ const string ASResource::AS_EQUAL = string("==");
+ const string ASResource::AS_PLUS_PLUS = string("++");
+ const string ASResource::AS_MINUS_MINUS = string("--");
+ const string ASResource::AS_NOT_EQUAL = string("!=");
+ const string ASResource::AS_GR_EQUAL = string(">=");
+ const string ASResource::AS_GR_GR = string(">>");
+ const string ASResource::AS_GR_GR_GR = string(">>>");
+ const string ASResource::AS_LS_EQUAL = string("<=");
+ const string ASResource::AS_LS_LS = string("<<");
+ const string ASResource::AS_LS_LS_LS = string("<<<");
+ const string ASResource::AS_ARROW = string("->");
+ const string ASResource::AS_AND = string("&&");
+ const string ASResource::AS_OR = string("||");
+ const string ASResource::AS_COLON_COLON = string("::");
+ const string ASResource::AS_PAREN_PAREN = string("()");
+ const string ASResource::AS_BLPAREN_BLPAREN = string("[]");
+
+ const string ASResource::AS_PLUS = string("+");
+ const string ASResource::AS_MINUS = string("-");
+ const string ASResource::AS_MULT = string("*");
+ const string ASResource::AS_DIV = string("/");
+ const string ASResource::AS_MOD = string("%");
+ const string ASResource::AS_GR = string(">");
+ const string ASResource::AS_LS = string("<");
+ const string ASResource::AS_NOT = string("!");
+ const string ASResource::AS_BIT_OR = string("|");
+ const string ASResource::AS_BIT_AND = string("&");
+ const string ASResource::AS_BIT_NOT = string("~");
+ const string ASResource::AS_BIT_XOR = string("^");
+ const string ASResource::AS_QUESTION = string("?");
+ const string ASResource::AS_COLON = string(":");
+ const string ASResource::AS_COMMA = string(",");
+ const string ASResource::AS_SEMICOLON = string(";");
+
+ const string ASResource::AS_FOREACH = string("foreach");
+ const string ASResource::AS_LOCK = string("lock");
+ const string ASResource::AS_UNSAFE = string("unsafe");
+ const string ASResource::AS_FIXED = string("fixed");
+ const string ASResource::AS_GET = string("get");
+ const string ASResource::AS_SET = string("set");
+ const string ASResource::AS_ADD = string("add");
+ const string ASResource::AS_REMOVE = string("remove");
+
+#ifdef USES_NAMESPACE
+}
+#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.
+ */
+
+
+#ifndef ASRES_H
+#define ASRES_H
+
+#include "compiler_defines.h"
+#include "ASStreamIterator.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+namespace astyle {
+
+class ASResource
+ {
+ public:
+ static const string AS_IF, AS_ELSE;
+ static const string AS_DO, AS_WHILE;
+ static const string AS_FOR;
+ static const string AS_SWITCH, AS_CASE, AS_DEFAULT;
+ static const string AS_TRY, AS_CATCH, AS_THROWS, AS_FINALLY;
+ static const string AS_PUBLIC, AS_PROTECTED, AS_PRIVATE;
+ static const string AS_CLASS, AS_STRUCT, AS_UNION, AS_INTERFACE, AS_NAMESPACE, AS_EXTERN;
+ static const string AS_STATIC;
+ static const string AS_CONST;
+ static const string AS_SYNCHRONIZED;
+ static const string AS_OPERATOR, AS_TEMPLATE;
+ static const string AS_OPEN_BRACKET, AS_CLOSE_BRACKET;
+ static const string AS_OPEN_LINE_COMMENT, AS_OPEN_COMMENT, AS_CLOSE_COMMENT;
+ static const string AS_BAR_DEFINE, AS_BAR_INCLUDE, AS_BAR_IF, AS_BAR_EL, AS_BAR_ENDIF;
+ static const string AS_RETURN;
+ static const string AS_ASSIGN, AS_PLUS_ASSIGN, AS_MINUS_ASSIGN, AS_MULT_ASSIGN;
+ static const string AS_DIV_ASSIGN, AS_MOD_ASSIGN, AS_XOR_ASSIGN, AS_OR_ASSIGN, AS_AND_ASSIGN;
+ static const string AS_GR_GR_ASSIGN, AS_LS_LS_ASSIGN, AS_GR_GR_GR_ASSIGN, AS_LS_LS_LS_ASSIGN;
+ static const string AS_EQUAL, AS_PLUS_PLUS, AS_MINUS_MINUS, AS_NOT_EQUAL, AS_GR_EQUAL, AS_GR_GR_GR, AS_GR_GR;
+ static const string AS_LS_EQUAL, AS_LS_LS_LS, AS_LS_LS, AS_ARROW, AS_AND, AS_OR;
+ static const string AS_COLON_COLON, AS_PAREN_PAREN, AS_BLPAREN_BLPAREN;
+ static const string AS_PLUS, AS_MINUS, AS_MULT, AS_DIV, AS_MOD, AS_GR, AS_LS;
+ static const string AS_NOT, AS_BIT_XOR, AS_BIT_OR, AS_BIT_AND, AS_BIT_NOT;
+ static const string AS_QUESTION, AS_COLON, AS_SEMICOLON, AS_COMMA;
+ static const string AS_ASM;
+ static const string AS_FOREACH, AS_LOCK, AS_UNSAFE, AS_FIXED;
+ static const string AS_GET, AS_SET, AS_ADD, AS_REMOVE;
+ };
+}
+#endif
+
+#ifndef ASSOURCEITERATOR_H
+#define ASSOURCEITERATOR_H
+
+#include <string>
+#include "compiler_defines.h"
+
+namespace astyle
+ {
+
+ class ASSourceIterator
+ {
+ public:
+ virtual bool hasMoreLines() const = 0;
+ virtual std::string nextLine() = 0;
+ };
+}
+
+#endif
+#include "compiler_defines.h"
+#include "ASStreamIterator.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+using namespace astyle;
+
+ASStreamIterator::ASStreamIterator(istream *in)
+{
+ inStream = in;
+}
+
+ASStreamIterator::~ASStreamIterator()
+{
+ delete inStream;
+}
+
+
+bool ASStreamIterator::hasMoreLines() const
+ {
+ if (*inStream)
+ return true;
+ else
+ return false;
+ }
+
+/*
+string ASStreamIterator::nextLine()
+{
+ char theInChar;
+ char peekedChar;
+ int theBufferPosn = 0;
+
+ //
+ // treat '\n', '\r', '\n\r' and '\r\n' as an endline.
+ //
+ while (theBufferPosn < 2047 && inStream->get(theInChar))
+ // while not eof
+ {
+ if (theInChar != '\n' && theInChar != '\r')
+ {
+ buffer[theBufferPosn] = theInChar;
+ theBufferPosn++;
+ }
+ else
+ {
+ peekedChar = inStream->peek();
+ if (peekedChar != theInChar && (peekedChar == '\r' || peekedChar == '\n') )
+ {
+ inStream->get(theInChar);
+ }
+ break;
+ }
+ }
+ buffer[theBufferPosn] = '\0';
+
+ return string(buffer);
+}
+*/
+
+
+string ASStreamIterator::nextLine()
+{
+ char *srcPtr;
+ char *filterPtr;
+
+ inStream->getline(buffer, 2047);
+ srcPtr = filterPtr = buffer;
+
+ while (*srcPtr != 0)
+ {
+ if (*srcPtr != '\r')
+ *filterPtr++ = *srcPtr;
+ srcPtr++;
+ }
+ *filterPtr = 0;
+
+ return string(buffer);
+}
+
+/*
+ * 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.
+ */
+
+
+#ifndef ASSTREAMITERATOR_H
+#define ASSTREAMITERATOR_H
+
+#include "ASSourceIterator.h"
+
+using namespace std;
+
+namespace astyle
+ {
+ class ASStreamIterator :
+ public ASSourceIterator
+ {
+ public:
+ ASStreamIterator(istream *in);
+ virtual ~ASStreamIterator();
+ bool hasMoreLines() const;
+ string nextLine();
+
+ private:
+ istream * inStream;
+ char buffer[2048];
+ };
+
+}
+
+#endif
+/***************************************************************************
+ charcodes.cpp - description
+ -------------------
+ begin : Wed Nov 24 2003
+ copyright : (C) 2003 by André 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. *
+ * *
+ ***************************************************************************/
+
+// FILE SHOULD BE REMOVED FROM PROJECT
+
+#ifndef CHAR_CODES
+#define CHAR_CODES
+
+#ifdef _WIN32
+
+#define AUML_LC 228
+#define OUML_LC 246
+#define UUML_LC 252
+
+#define AUML_UC 196
+#define OUML_UC 214
+#define UUML_UC 220
+
+
+#define AACUTE_LC 225
+#define EACUTE_LC 233
+#define OACUTE_LC 243
+#define UACUTE_LC 250
+
+#define AACUTE_UC 193
+#define EACUTE_UC 201
+#define OACUTE_UC 211
+#define UACUTE_UC 218
+
+#define AGRAVE_LC 224
+#define EGRAVE_LC 232
+#define OGRAVE_LC 242
+#define UGRAVE_LC 249
+
+#define AGRAVE_UC 192
+#define EGRAVE_UC 200
+#define OGRAVE_UC 210
+#define UGRAVE_UC 217
+
+#define SZLIG 223
+
+/* DOS CONSOLE CODES
+#define AUML_LC 132
+#define OUML_LC 148
+#define UUML_LC 129
+
+#define AUML_UC 142
+#define OUML_UC 153
+#define UUML_UC 154
+
+
+#define AACUTE_LC 160
+#define EACUTE_LC 130
+#define OACUTE_LC 162
+#define UACUTE_LC 163
+
+#define AACUTE_UC 181
+#define EACUTE_UC 144
+#define OACUTE_UC 224
+#define UACUTE_UC 233
+
+#define AGRAVE_LC 133
+#define EGRAVE_LC 138
+#define OGRAVE_LC 149
+#define UGRAVE_LC 151
+
+#define AGRAVE_UC 183
+#define EGRAVE_UC 212
+#define OGRAVE_UC 227
+#define UGRAVE_UC 235
+
+#define SZLIG 225
+*/
+
+#else
+
+#define AUML_LC 164
+#define OUML_LC 182
+#define UUML_LC 188
+
+#define AUML_UC 132
+#define OUML_UC 150
+#define UUML_UC 156
+
+
+#define AACUTE_LC 161
+#define EACUTE_LC 169
+#define OACUTE_LC 179
+#define UACUTE_LC 186
+
+#define AACUTE_UC 129
+#define EACUTE_UC 137
+#define OACUTE_UC 147
+#define UACUTE_UC 154
+
+#define AGRAVE_LC 160
+#define EGRAVE_LC 168
+#define OGRAVE_LC 178
+#define UGRAVE_LC 185
+
+#define AGRAVE_UC 128
+#define EGRAVE_UC 136
+#define OGRAVE_UC 146
+#define UGRAVE_UC 153
+
+#define SZLIG 159
+
+#endif
+
+#endif
+/***************************************************************************
+ cmdlineoptions.cpp - description
+ -------------------
+ begin : Sun Nov 25 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 "cmdlineoptions.h"
+
+using namespace std;
+
+/* Siehe man getopt (3)
+ Konstruktor legt Optionen und Argumente fest
+*/
+CmdLineOptions::CmdLineOptions(int argc, char *argv[]):
+ numberSpaces(0),
+ wrappingStyle(highlight::WRAP_DISABLED),
+ outputType (highlight::HTML),
+ opt_language (false),
+ opt_include_style (false),
+ opt_help (false),
+ opt_version (false),
+ opt_verbose (false),
+ opt_linenumbers (false),
+ opt_style (false),
+ opt_batch_mode (false),
+ opt_fragment (false) ,
+ opt_attach_line_anchors (false),
+ opt_show_themes (false),
+ opt_show_langdefs (false),
+ opt_printindex(false),
+ opt_quiet(false),
+ opt_xslfo_fop(false),
+ opt_replacequotes(false),
+ opt_print_progress(false),
+ opt_fill_zeroes(false),
+ opt_stylepath_explicit(false),
+ opt_force_output(false),
+ configFileRead(false),
+ helpLang("en"),
+ charset("ISO-8859-1")
+{
+
+ loadConfigurationFile();
+
+ int c, option_index = 0;
+ static struct option long_options[] =
+ {
+ {OPT_OUT, 1, 0, S_OPT_OUT},
+ {OPT_IN, 1, 0, S_OPT_IN},
+ {OPT_SYNTAX, 1, 0, S_OPT_SYNTAX},
+ {OPT_VERBOSE, 0, 0, S_OPT_VERBOSE},
+ {OPT_INC_STYLE, 0, 0, S_OPT_INC_STYLE},
+ {OPT_HELP, 0, 0, S_OPT_HELP},
+ {OPT_HELPINT, 1, 0, S_OPT_HELPINT},
+ {OPT_LINENO,0,0,S_OPT_LINENO},
+ {OPT_STYLE, 1,0,S_OPT_STYLE},
+ {OPT_STYLE_OUT, 1, 0,S_OPT_STYLE_OUT},
+ {OPT_STYLE_IN, 1, 0,S_OPT_STYLE_IN},
+ {OPT_DELTABS,1,0,S_OPT_DELTABS},
+ {OPT_XHTML, 0,0,S_OPT_XHTML},
+ {OPT_RTF, 0,0,S_OPT_RTF},
+ {OPT_TEX,0, 0,S_OPT_TEX},
+ {OPT_LATEX,0, 0,S_OPT_LATEX},
+ {OPT_XSLFO,0, 0,S_OPT_XSLFO},
+ {OPT_ANSI,0, 0,S_OPT_ANSI},
+ {OPT_XML,0, 0,S_OPT_XML},
+ {OPT_BATCHREC,1,0,S_OPT_BATCHREC},
+ {OPT_FRAGMENT,0,0,S_OPT_FRAGMENT},
+ {OPT_ANCHORS, 0,0,S_OPT_ANCHORS },
+ {OPT_LISTTHEMES, 0,0,S_OPT_LISTTHEMES },
+ {OPT_LISTLANGS, 0,0,S_OPT_LISTLANGS },
+ {OPT_OUTDIR,1,0,S_OPT_OUTDIR},
+ {OPT_VERSION,0,0,0},
+ {OPT_FORMATSTYLE,1,0,S_OPT_FORMATSTYLE},
+ {OPT_DATADIR,1,0,S_OPT_DATADIR},
+ {OPT_ADDDATADIR,1,0,S_OPT_ADDDATADIR},
+ {OPT_INDEXFILE,0,0,S_OPT_INDEXFILE},
+ {OPT_WRAP,0,0,S_OPT_WRAP},
+ {OPT_WRAPSIMPLE,0,0,S_OPT_WRAPSIMPLE},
+ {OPT_QUIET,0,0,S_OPT_QUIET},
+ {OPT_REPLACE_QUOTES,0,0,S_OPT_REPLACE_QUOTES},
+ {OPT_PROGRESSBAR,0,0,S_OPT_PROGRESSBAR},
+ {OPT_FILLZEROES,0,0,S_OPT_FILLZEROES},
+ {OPT_ENCODING,1,0,S_OPT_ENCODING},
+
+ //remove as soon as APAche fixes the bug in FOP (0.20.5)
+ {OPT_FOP,0,0,S_OPT_FOP},
+
+ //deprecated
+ {OPT_CSSOUT,1,0,0},
+ {OPT_CSSIN,1,0,0},
+ {OPT_INC_CSS,0,0,0},
+ {OPT_FORCE_OUTPUT,0,0,0},
+
+ {0, 0, 0, 0}
+ };
+
+ while (1)
+ {
+ c = getopt_long (argc, argv,S_OPTIONS_STRING,long_options, &option_index);
+ if (c == -1)
+ break;
+
+ switch (c)
+ {
+ case 0: // long options
+ if (long_options[option_index].name==OPT_VERSION) {
+ opt_version = true;
+ }
+ if (long_options[option_index].name==OPT_CSSOUT) {
+ styleOutFilename=string(optarg);
+ printDeprecatedWarning(OPT_CSSOUT, OPT_STYLE_OUT);
+ }
+ if (long_options[option_index].name==OPT_CSSIN) {
+ styleInFilename=string(optarg);
+ printDeprecatedWarning(OPT_CSSIN, OPT_STYLE_IN);
+ }
+ if (long_options[option_index].name==OPT_INC_CSS) {
+ opt_include_style = true;
+ printDeprecatedWarning(OPT_INC_CSS, OPT_INC_STYLE);
+ }
+ if (long_options[option_index].name==OPT_FORCE_OUTPUT) {
+ opt_force_output = true;
+ }
+ break;
+ case S_OPT_OUT:
+ outFilename=string(optarg);
+ break;
+ case S_OPT_IN:
+ inputFileNames.push_back(string(optarg));
+ break;
+ case S_OPT_STYLE_OUT:
+ styleOutFilename=string(optarg);
+ opt_stylepath_explicit=true;
+ break;
+ case S_OPT_STYLE_IN:
+ styleInFilename=string(optarg);
+ break;
+ case S_OPT_VERBOSE:
+ opt_verbose = true;
+ break;
+ case S_OPT_QUIET:
+ opt_quiet = true;
+ break;
+ case S_OPT_INC_STYLE:
+ opt_include_style = true;
+ break;
+ case S_OPT_HELPINT:
+ helpLang=string(optarg);
+ case S_OPT_HELP:
+ opt_help = true;
+ break;
+ case S_OPT_LINENO:
+ opt_linenumbers = true;
+ break;
+ case '?':
+ //opt_help = true;
+ break;
+ case S_OPT_STYLE:
+ styleName=string(optarg);
+ opt_style = true;
+ break;
+ case S_OPT_SYNTAX:
+ language=string(optarg);
+ opt_language = true;
+ break;
+ case S_OPT_DELTABS:
+ numberSpaces = StringTools::str2int (string(optarg));
+ break;
+ case S_OPT_XHTML:
+ outputType=highlight::XHTML;
+ break;
+ case S_OPT_RTF:
+ outputType=highlight::RTF;
+ break;
+ case S_OPT_TEX:
+ outputType=highlight::TEX;
+ break;
+ case S_OPT_LATEX:
+ outputType=highlight::LATEX;
+ break;
+ case S_OPT_XSLFO:
+ outputType=highlight::XSLFO;
+ break;
+ case S_OPT_ANSI:
+ outputType=highlight::ANSI;
+ break;
+ case S_OPT_XML:
+ outputType=highlight::XML;
+ break;
+ case S_OPT_BATCHREC:
+ opt_batch_mode = true;
+ readDirectory(string(optarg));
+ break;
+ case S_OPT_FRAGMENT:
+ opt_fragment = true;
+ break;
+ case S_OPT_ANCHORS:
+ opt_attach_line_anchors = true;
+ break;
+ case S_OPT_LISTTHEMES:
+ opt_show_themes = true;
+ break;
+ case S_OPT_LISTLANGS:
+ opt_show_langdefs = true;
+ break;
+ case S_OPT_OUTDIR:
+ outDirectory = validateDirPath(string(optarg));
+ break;
+ case S_OPT_FORMATSTYLE:
+ indentScheme =string(optarg);
+ break;
+ case S_OPT_ENCODING:
+ charset =string(optarg);
+ break;
+ case S_OPT_DATADIR:
+ dataDir=validateDirPath(string(optarg));
+ break;
+ case S_OPT_ADDDATADIR:
+ additionalDataDir=validateDirPath(string(optarg));
+ break;
+ case S_OPT_INDEXFILE:
+ opt_printindex=true;
+ break;
+ case S_OPT_WRAPSIMPLE:
+ wrappingStyle = highlight::WRAP_SIMPLE;
+ break;
+ case S_OPT_WRAP:
+ wrappingStyle = highlight::WRAP_DEFAULT;
+ break;
+ case S_OPT_FOP:
+ opt_xslfo_fop=true;
+ break;
+ case S_OPT_REPLACE_QUOTES:
+ opt_replacequotes=true;
+ break;
+ case S_OPT_PROGRESSBAR:
+ opt_print_progress=true;
+ break;
+ case S_OPT_FILLZEROES:
+ opt_fill_zeroes=true;
+ break;
+ default:
+ cerr <<"higlight: Unknown option " <<c<< endl;
+ }
+ }
+
+ if (optind < argc) //still args left
+ {
+ if (inputFileNames.empty()) {
+ while (optind < argc){
+ inputFileNames.push_back(string(argv[optind++]));
+ }
+ }
+ } else if (inputFileNames.empty()) {
+ inputFileNames.push_back("");
+ }
+ if (printDebugInfo() && configFileRead) {
+ cout << "Configuration file \""<<configFilePath<<"\" was read.\n";
+ }
+}
+
+CmdLineOptions::~CmdLineOptions(){
+}
+
+const string &CmdLineOptions::getSingleOutFilename()
+ {
+ if (!inputFileNames.empty() && !outDirectory.empty()) {
+ if (outFilename.empty()) {
+ outFilename = outDirectory;
+ int delim = getSingleInFilename().find_last_of(Platform::pathSeparator)+1;
+ outFilename += getSingleInFilename().substr((delim>-1)?delim:0)
+ + getOutFileSuffix();
+ }
+ }
+ return outFilename;
+ }
+
+const string &CmdLineOptions::getSingleInFilename() const
+ {
+ return inputFileNames[0];
+ }
+
+const string &CmdLineOptions::getOutDirectory()
+ {
+ if (!outFilename.empty() && !enableBatchMode()){
+ outDirectory=getDirName(outFilename);
+ }
+ return outDirectory;
+ }
+
+const string CmdLineOptions::getStyleOutFilename() const
+ {
+ if (!styleOutFilename.empty()) return styleOutFilename;
+ return (outputType==highlight::HTML ||
+ outputType==highlight::XHTML)? "highlight.css":"highlight.sty";
+ }
+const string &CmdLineOptions::getStyleInFilename() const
+ {
+ return styleInFilename;
+ }
+int CmdLineOptions::getNumberSpaces() const
+ {
+ return numberSpaces;
+ }
+bool CmdLineOptions::printVersion()const
+ {
+ return opt_version;
+ }
+bool CmdLineOptions::printHelp()const
+ {
+ return opt_help;
+ }
+bool CmdLineOptions::printDebugInfo()const
+ {
+ return opt_verbose;
+ }
+bool CmdLineOptions::quietMode()const
+ {
+ return opt_quiet;
+ }
+bool CmdLineOptions::includeStyleDef()const
+ {
+ return opt_include_style;
+ }
+
+bool CmdLineOptions::formatSupportsExtStyle(){
+ return outputType==highlight::HTML ||
+ outputType==highlight::XHTML ||
+ outputType==highlight::LATEX ||
+ outputType==highlight::TEX;
+}
+
+bool CmdLineOptions::printLineNumbers()const
+ {
+ return opt_linenumbers;
+ }
+
+string CmdLineOptions::getStyleName()const
+ {
+ return ( ( opt_style) ? styleName+".style" : "kwrite.style" );
+ }
+bool CmdLineOptions::enableBatchMode()const{
+ return inputFileNames.size()>1 || opt_batch_mode;
+}
+bool CmdLineOptions::fragmentOutput()const{
+ return opt_fragment;
+}
+string CmdLineOptions::getOutFileSuffix()const{
+ switch (outputType){
+ case highlight::XHTML: return ".xhtml";
+ case highlight::RTF: return ".rtf";
+ case highlight::TEX:
+ case highlight::LATEX: return ".tex";
+ case highlight::XSLFO: return ".fo";
+ case highlight::XML: return ".xml";
+ default: return ".html";
+ }
+}
+string CmdLineOptions::getDirName(const string & path) {
+ size_t dirNameLength=path.rfind(Platform::pathSeparator);
+ return (dirNameLength==string::npos)?string():path.substr(0, dirNameLength+1);
+}
+bool CmdLineOptions::attachLineAnchors()const{
+ return opt_attach_line_anchors;
+}
+bool CmdLineOptions::showThemes()const{
+ return opt_show_themes;
+}
+bool CmdLineOptions::showLangdefs()const{
+ return opt_show_langdefs;
+}
+bool CmdLineOptions::outDirGiven()const{
+ return !outFilename.empty();
+}
+bool CmdLineOptions::fopCompatible() const {
+ return opt_xslfo_fop;
+}
+bool CmdLineOptions::replaceQuotes() const {
+ return opt_replacequotes;
+}
+bool CmdLineOptions::getFlag( const string& paramVal){
+ return StringTools::lowerCase(paramVal)=="true";
+}
+bool CmdLineOptions::formattingEnabled(){
+ return !indentScheme.empty();
+}
+bool CmdLineOptions::dataDirGiven()const {
+ return !dataDir.empty();
+}
+bool CmdLineOptions::additionalDataDirGiven()const {
+ return !additionalDataDir.empty();
+}
+const string &CmdLineOptions::getDataDir() const {
+ return dataDir;
+}
+const string &CmdLineOptions::getIndentScheme() const {
+ return indentScheme;
+}
+const string &CmdLineOptions::getAdditionalDataDir()const{
+ return additionalDataDir;
+}
+const string &CmdLineOptions::getLanguage() const {
+ return language;
+}
+const string&CmdLineOptions::getCharSet() const{
+ return charset;
+}
+bool CmdLineOptions::printIndexFile() const{
+ return opt_printindex && (outputType==highlight::HTML ||
+ outputType==highlight::XHTML);
+}
+bool CmdLineOptions::printProgress() const{
+ return opt_print_progress;
+}
+bool CmdLineOptions::fillLineNrZeroes() const{
+ return opt_fill_zeroes;
+}
+bool CmdLineOptions::syntaxGiven() const{
+ return opt_language;
+}
+bool CmdLineOptions::omitEncodingName() const{
+ return StringTools::lowerCase(charset)=="none";
+}
+bool CmdLineOptions::forceOutput() const{
+ return opt_force_output;
+}
+const string CmdLineOptions::getHelpLang()const{
+ return helpLang+".help";
+}
+highlight::WrapMode CmdLineOptions::getWrappingStyle() const {
+ return wrappingStyle;
+}
+const vector <string> & CmdLineOptions::getInputFileNames() const{
+ return inputFileNames;
+}
+void CmdLineOptions::readDirectory(const string & wildcard){
+ // get matching files, use recursive search
+ bool directoryOK=Platform::getDirectoryEntries(inputFileNames, wildcard, true);
+ if (!directoryOK)
+ {
+ cerr << "highlight: No files matched the pattern \""
+ << wildcard << "\"."<< endl;
+ }
+}
+void CmdLineOptions::loadConfigurationFile()
+{
+ #ifndef _WIN32
+ #ifdef CONFIG_FILE_PATH
+ configFilePath=CONFIG_FILE_PATH;
+ #else
+ char* homeEnv=getenv("HOME");
+ if (homeEnv==NULL) return;
+ configFilePath=string(homeEnv)+"/.highlightrc";
+ #endif
+ #else
+ configFilePath = Platform::getAppPath() + "highlight.conf";
+ #endif
+ ConfigurationReader presets(configFilePath);
+
+ if (presets.found())
+ {
+ string paramVal;
+ configFileRead=true;
+
+ styleOutFilename = presets.getParameter(OPT_STYLE_OUT);
+ styleInFilename = presets.getParameter(OPT_STYLE_IN);
+ styleName = presets.getParameter(OPT_STYLE);
+ opt_style = !styleName.empty();
+ language = presets.getParameter(OPT_SYNTAX);
+ opt_language = !language.empty();
+ numberSpaces = StringTools::str2int(presets.getParameter(OPT_DELTABS));
+ indentScheme = presets.getParameter(OPT_FORMATSTYLE);
+
+ paramVal = presets.getParameter(OPT_DATADIR);
+ if (!paramVal.empty()) {
+ dataDir=validateDirPath( paramVal);
+ }
+ paramVal = presets.getParameter(OPT_ADDDATADIR);
+ if (!paramVal.empty()) {
+ additionalDataDir=validateDirPath(paramVal);
+ }
+ paramVal = presets.getParameter(OPT_OUTDIR);
+ if (!paramVal.empty()) {
+ outDirectory=validateDirPath(paramVal);
+ }
+ paramVal = presets.getParameter(OPT_ENCODING);
+ if (!paramVal.empty()) {
+ charset=paramVal;
+ }
+
+ opt_include_style=getFlag(presets.getParameter(OPT_INC_STYLE));
+ opt_verbose=getFlag(presets.getParameter(OPT_VERBOSE));
+ opt_linenumbers=getFlag(presets.getParameter(OPT_LINENO));
+ opt_fragment=getFlag(presets.getParameter(OPT_FRAGMENT));
+ opt_attach_line_anchors=getFlag(presets.getParameter(OPT_ANCHORS));
+ opt_printindex=getFlag(presets.getParameter(OPT_INDEXFILE));
+ opt_quiet=getFlag(presets.getParameter(OPT_QUIET));
+ opt_xslfo_fop=getFlag(presets.getParameter(OPT_FOP));
+ opt_replacequotes=getFlag(presets.getParameter(OPT_REPLACE_QUOTES));
+ opt_print_progress=getFlag(presets.getParameter(OPT_PROGRESSBAR));
+ opt_fill_zeroes=getFlag(presets.getParameter(OPT_FILLZEROES));
+
+ if (getFlag(presets.getParameter(OPT_WRAP))) {
+ wrappingStyle=highlight::WRAP_DEFAULT;
+ }
+ if (getFlag(presets.getParameter(OPT_WRAPSIMPLE))) {
+ wrappingStyle=highlight::WRAP_SIMPLE;
+ }
+ if (getFlag(presets.getParameter(OPT_XHTML))) {
+ outputType=highlight::XHTML;
+ } else if (getFlag(presets.getParameter(OPT_RTF))) {
+ outputType=highlight::RTF;
+ } else if (getFlag(presets.getParameter(OPT_TEX))) {
+ outputType=highlight::TEX;
+ } else if (getFlag(presets.getParameter(OPT_LATEX))) {
+ outputType=highlight::LATEX;
+ } else if (getFlag(presets.getParameter(OPT_XSLFO))) {
+ outputType=highlight::XSLFO;
+ } else if (getFlag(presets.getParameter(OPT_ANSI))) {
+ outputType=highlight::ANSI;
+ } else if (getFlag(presets.getParameter(OPT_XML))) {
+ outputType=highlight::XML;
+ }
+ }
+}
+
+string CmdLineOptions::validateDirPath(const string & path){
+ return (path[path.length()-1] !=Platform::pathSeparator)?
+ path+Platform::pathSeparator : path;
+}
+
+highlight::OutputType CmdLineOptions::getOutputType() const {
+ return outputType;
+}
+
+void CmdLineOptions::printDeprecatedWarning(const char *oldOption, const char *newOption){
+ cerr << "Warning: Long option \""<<oldOption << "\" is DEPRECATED.";
+ cerr << " Use \""<<newOption << "\" instead.\n";
+}
+/***************************************************************************
+ cmdlineoptions.h - description
+ -------------------
+ begin : Sun Nov 25 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 CMDLINEOPTIONS_H
+#define CMDLINEOPTIONS_H
+
+#include <string>
+#include <map>
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+
+#include "platform_fs.h"
+#include "configurationreader.h"
+#include "datadir.h"
+#include "enums.h"
+
+#ifdef _WIN32
+ #include <windows.h>
+#endif
+
+// If your system does not know getopt_long, define USE_LOCAL_GETOPT
+#if defined(_WIN32) || defined(__SVR4) || defined(__sun__)
+ // some compilers don't like redefinitions...
+ #ifndef USE_LOCAL_GETOPT
+ #define USE_LOCAL_GETOPT
+ #endif
+#endif
+
+#ifdef USE_LOCAL_GETOPT
+ #include "getopt.h"
+#else
+ #include <getopt.h>
+#endif
+
+#define OPT_VERBOSE "verbose"
+#define OPT_INC_STYLE "include-style"
+#define OPT_HELP "help"
+#define OPT_LINENO "linenumbers"
+#define OPT_XHTML "xhtml"
+#define OPT_RTF "rtf"
+#define OPT_TEX "tex"
+#define OPT_LATEX "latex"
+#define OPT_XSLFO "xsl-fo"
+#define OPT_FRAGMENT "fragment"
+#define OPT_ANCHORS "anchors"
+#define OPT_LISTTHEMES "list-themes"
+#define OPT_LISTLANGS "list-langs"
+#define OPT_VERSION "version"
+#define OPT_IN "input"
+#define OPT_OUT "output"
+#define OPT_SYNTAX "syntax"
+#define OPT_STYLE "style"
+#define OPT_STYLE_OUT "style-outfile"
+#define OPT_STYLE_IN "style-infile"
+
+#define OPT_DELTABS "replace-tabs"
+#define OPT_BATCHREC "batch-recursive"
+#define OPT_OUTDIR "outdir"
+#define OPT_FORMATSTYLE "format-style"
+#define OPT_DATADIR "data-dir"
+#define OPT_ADDDATADIR "add-data-dir"
+#define OPT_INDEXFILE "print-index"
+#define OPT_HELPINT "help-int"
+#define OPT_WRAP "wrap"
+#define OPT_WRAPSIMPLE "wrap-simple"
+#define OPT_QUIET "quiet"
+#define OPT_REPLACE_QUOTES "replace-quotes"
+#define OPT_FOP "fop-compatible"
+#define OPT_PROGRESSBAR "progress"
+#define OPT_FILLZEROES "zeroes"
+#define OPT_ANSI "ansi"
+#define OPT_XML "xml"
+#define OPT_ENCODING "encoding"
+#define OPT_FORCE_OUTPUT "force"
+
+#define S_OPT_ANSI 'A'
+#define S_OPT_OUT 'o'
+#define S_OPT_IN 'i'
+#define S_OPT_SYNTAX 'S'
+#define S_OPT_VERBOSE 'v'
+#define S_OPT_INC_STYLE 'I'
+#define S_OPT_HELP 'h'
+#define S_OPT_HELPINT 'H'
+#define S_OPT_LINENO 'l'
+#define S_OPT_STYLE 's'
+#define S_OPT_STYLE_OUT 'c'
+#define S_OPT_STYLE_IN 'e'
+#define S_OPT_DELTABS 't'
+#define S_OPT_XHTML 'X'
+#define S_OPT_RTF 'R'
+#define S_OPT_TEX 'T'
+#define S_OPT_LATEX 'L'
+#define S_OPT_XSLFO 'Y'
+#define S_OPT_XML 'Z'
+#define S_OPT_BATCHREC 'B'
+#define S_OPT_FRAGMENT 'f'
+#define S_OPT_ANCHORS 'a'
+#define S_OPT_LISTTHEMES 'w'
+#define S_OPT_LISTLANGS 'p'
+#define S_OPT_OUTDIR 'O'
+
+#define S_OPT_FORMATSTYLE 'F'
+#define S_OPT_DATADIR 'D'
+#define S_OPT_ADDDATADIR 'E'
+#define S_OPT_INDEXFILE 'C'
+#define S_OPT_WRAP 'W'
+#define S_OPT_WRAPSIMPLE 'V'
+#define S_OPT_QUIET 'q'
+#define S_OPT_FOP 'g'
+#define S_OPT_REPLACE_QUOTES 'r'
+#define S_OPT_VERSION 'Q'
+#define S_OPT_PROGRESSBAR 'P'
+#define S_OPT_FILLZEROES 'z'
+#define S_OPT_ENCODING 'u'
+
+// deprecated:
+#define OPT_CSSOUT "css-outfile"
+#define OPT_CSSIN "css-infile"
+#define OPT_INC_CSS "include-css"
+
+
+#define S_OPTIONS_STRING "o:i:S:B:O:s:c:e:t:u:F:D:H:E:afghlvwpqrzACILYRTZXUV::W::P"
+
+using namespace std;
+
+/**Command line options*/
+
+class CmdLineOptions
+ {
+ public:
+
+ /**Constructor
+ \param argc Argument count
+ \param argv Argument strings
+ */
+ CmdLineOptions(int argc, char *argv[]);
+ ~CmdLineOptions();
+
+ /** \return Single output file name*/
+ const string &getSingleOutFilename();
+
+ /** \return Single input file name*/
+ const string &getSingleInFilename() const;
+
+ /** \return Output directory*/
+ const string& getOutDirectory() ;
+
+ /** \return Style output file name*/
+ const string getStyleOutFilename() const;
+
+ /** \return Style input file name*/
+ const string&getStyleInFilename() const;
+
+ /** \return Char set*/
+ const string&getCharSet() const;
+
+ /** \return Number of spaces to replace a tab*/
+ int getNumberSpaces() const;
+
+ /** \return True if version information should be printed*/
+ bool printVersion() const;
+
+ /** \return True if help information should be printed*/
+ bool printHelp() const;
+
+ /** \return True if debug information should be printed*/
+ bool printDebugInfo()const;
+
+ /** \return True if Style definition should be included in output*/
+ bool includeStyleDef() const;
+
+ /** \return True if line numbers should be printed*/
+ bool printLineNumbers() const;
+
+ /** \return colour theme name */
+ string getStyleName()const ;
+
+ /** gibt true zurck, falls deutsche Hilfe ausgegeben werden soll */
+ int helpLanguage() const;
+
+ /** \return True if batch mode is active*/
+ bool enableBatchMode() const;
+
+ /** \return True if output shluld be fragmented*/
+ bool fragmentOutput() const;
+
+ /** \return output file suffix */
+ string getOutFileSuffix() const;
+
+ /** \return True if anchors should be attached to line numbers*/
+ bool attachLineAnchors() const;
+
+ /** \return True if list of installed themes should be printed*/
+ bool showThemes() const;
+
+ /** \return True if list of installed language definitions should be printed*/
+ bool showLangdefs() const;
+
+ /** \return True if loutput directory is given*/
+ bool outDirGiven() const;
+
+ /** \return True if refomatting is enabled*/
+ bool formattingEnabled();
+
+ /** \return True if a new data directory is given*/
+ bool dataDirGiven()const;
+
+ /** \return True if an additional data directory is given*/
+ bool additionalDataDirGiven()const;
+
+ /** \return True if index file should be printed*/
+ bool printIndexFile() const;
+
+ /** \return True if quotes should be replaced by /dq in LaTeX*/
+ bool replaceQuotes() const;
+
+ /** \return Data directory*/
+ const string &getDataDir()const;
+
+ /** \return Additional data directory*/
+ const string &getAdditionalDataDir()const;
+
+ /** \return True if language syntax is given*/
+ bool syntaxGiven() const;
+
+ /** \return True if quiet mode is active*/
+ bool quietMode() const;
+
+ /** \return True if XSL-FO output should be FOP compatible*/
+ bool fopCompatible() const;
+
+ /** \return True if progress bar should be printed in batch mode */
+ bool printProgress() const;
+
+ /** \return True if line numbers are filled with leading zeroes */
+ bool fillLineNrZeroes() const;
+
+ /** \return name of help message file*/
+ const string getHelpLang() const;
+
+ /** \return programming language */
+ const string &getLanguage()const ;
+
+ /** \return Wrapping style*/
+ highlight::WrapMode getWrappingStyle() const;
+
+ /** \return List of input file names*/
+ const vector <string> & getInputFileNames() const;
+
+ /** \return Name of indentation scheme file */
+ const string &getIndentScheme() const;
+
+ /** \return Output file format */
+ highlight::OutputType getOutputType() const;
+
+ /** \return True if chosen output format supports referenced style files */
+ bool formatSupportsExtStyle();
+
+ /** \return True if style output path was defined by user*/
+ bool styleOutPathDefined() const{
+ return opt_stylepath_explicit;
+ }
+
+ /** \return True if encoding nasme should be omitted in output*/
+ bool omitEncodingName() const;
+
+ /** \return True if output should be generated if languege type is unknown*/
+ bool forceOutput() const;
+
+ private:
+
+ int numberSpaces; // number of spaces which replace a tab
+ highlight::WrapMode wrappingStyle; // line wrapping mode
+ highlight::OutputType outputType;
+
+ // name of single output file
+ string outFilename,
+ // output directory
+ outDirectory,
+ // programming language which will be loaded
+ language,
+ // name of colour theme
+ styleName,
+ // name of external style file
+ styleOutFilename,
+ // name of file to be included in external style file
+ styleInFilename,
+ // used to define data directories at runtime
+ dataDir, additionalDataDir;
+ // name of indenation scheme
+ string indentScheme;
+
+ bool opt_language;
+ bool opt_include_style;
+ bool opt_help;
+ bool opt_version ;
+ bool opt_verbose;
+ bool opt_linenumbers;
+ bool opt_style;
+ bool opt_batch_mode;
+ bool opt_fragment;
+ bool opt_attach_line_anchors;
+ bool opt_show_themes;
+ bool opt_show_langdefs;
+ bool opt_asformat_output;
+ bool opt_printindex;
+ bool opt_quiet;
+ bool opt_xslfo_fop;
+ bool opt_replacequotes;
+ bool opt_print_progress;
+ bool opt_fill_zeroes;
+ bool opt_stylepath_explicit;
+ bool opt_force_output;
+
+ bool configFileRead;
+
+ string helpLang, charset;
+ string configFilePath;
+
+ // list of all input file names
+ vector <string> inputFileNames;
+
+ /** load highlight configuration file */
+ void loadConfigurationFile();
+
+ /** \return file suffix */
+ string getFileSuffix( const string & fileName) const;
+
+ /** \return directory name of path */
+ string getDirName( const string & path);
+
+ /** get all entries in the directory defined by wildcard */
+ void readDirectory(const string & wildcard);
+
+ /** \return Boolean value of paramVal */
+ bool getFlag(const string& paramVal);
+
+ /** \return Valid path name */
+ string validateDirPath(const string & path);
+
+ void printDeprecatedWarning(const char *oldOption, const char *newOption);
+ };
+
+#endif
+/***************************************************************************
+ codeparser.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 "codegenerator.h"
+
+#include "htmlgenerator.h"
+#include "xhtmlgenerator.h"
+#include "rtfgenerator.h"
+#include "latexgenerator.h"
+#include "texgenerator.h"
+#include "xslfogenerator.h"
+#include "xmlgenerator.h"
+#ifndef __WXMSW__
+ #include "ansigenerator.h"
+#endif
+
+
+using namespace std;
+
+namespace highlight {
+
+CodeGenerator* CodeGenerator::generator=NULL;
+
+CodeGenerator* 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
+ ) {
+ if (generator==NULL){
+ switch (type){
+ case TEX:
+ generator = new TexGenerator (styleInfoPath);
+ break;
+ case LATEX:
+ generator = new LatexGenerator(styleInfoPath, replaceQuotes);
+ break;
+ case RTF:
+ generator = new RtfGenerator (styleInfoPath);
+ break;
+ case XSLFO:
+ generator = new XslFoGenerator(styleInfoPath, encoding, omitEncoding,
+ fopCompatible);
+ break;
+ case XML:
+ generator = new XmlGenerator(styleInfoPath,encoding, omitEncoding);
+ break;
+ case XHTML:
+ generator = new XHtmlGenerator(styleInfoPath, encoding, omitEncoding,
+ attachAnchors);
+ break;
+ #ifndef __WXMSW__
+ case ANSI:
+ generator = new AnsiGenerator (styleInfoPath);
+ break;
+ #endif
+ default:
+ generator = new HtmlGenerator(styleInfoPath, encoding, omitEncoding,
+ attachAnchors);
+ }
+ }
+ generator->setType(type);
+ generator->setStyleInputPath(styleInPath);
+ generator->setStyleOutputPath(styleOutPath);
+ generator->setIncludeStyle(includeStyle);
+ generator->setPrintLineNumbers(ln);
+ generator->setPrintZeroes(lnz);
+ generator->setFragmentCode(fragment);
+ generator->setPreformatting(lineWrappingMode,
+ (generator->getPrintLineNumbers()) ?
+ MAX_LINE__WIDTH - LINE_NUMBER_WIDTH : MAX_LINE__WIDTH,
+ numSpaces );
+ return generator;
+}
+
+void CodeGenerator::deleteInstance(){
+ delete generator;
+ generator=NULL;
+}
+
+
+CodeGenerator::CodeGenerator():
+ in(NULL),
+ out(NULL),
+ maskWs(false),
+ excludeWs(false),
+ fragmentOutput(false),
+ showLineNumbers (false),
+ lineNumberFillZeroes(false),
+ lineNumber(0),
+ includeStyleDef(false),
+ lineIndex(0),
+ formatter(NULL),
+ preFormatter(NULL),
+ formattingEnabled(false),
+ formattingPossible(false),
+ outputType(highlight::HTML)
+{}
+
+CodeGenerator::CodeGenerator(const string &colourTheme)
+ :in(NULL),
+ out(NULL),
+ maskWs(false),
+ excludeWs(false),
+ fragmentOutput(false),
+ showLineNumbers (false),
+ lineNumberFillZeroes(false),
+ lineNumber(0),
+ includeStyleDef(false),
+ stylePath(colourTheme),
+ lineIndex(0),
+ formatter(NULL),
+ preFormatter(NULL),
+ formattingEnabled(false),
+ formattingPossible(false),
+ outputType(highlight::HTML)
+{
+ line.reserve(100);
+ docStyle.load(stylePath);
+}
+
+CodeGenerator::~CodeGenerator()
+{
+ delete preFormatter;
+ delete formatter;
+}
+
+
+/** Getter and Setter*/
+
+void CodeGenerator::setPrintLineNumbers(bool flag){
+ showLineNumbers=flag;
+}
+
+bool CodeGenerator::getPrintLineNumbers(){
+ return showLineNumbers;
+}
+
+void CodeGenerator::setPrintZeroes(bool flag){
+ lineNumberFillZeroes=flag;
+}
+
+bool CodeGenerator::getPrintZeroes(){
+ return lineNumberFillZeroes;
+}
+
+void CodeGenerator::setFragmentCode(bool flag){
+ fragmentOutput=flag;
+}
+
+void CodeGenerator::setIncludeStyle(bool flag){
+ includeStyleDef = flag;
+}
+
+void CodeGenerator::setStyleInputPath(const string& path){
+ styleInputPath = path;
+}
+void CodeGenerator::setStyleOutputPath(const string& path){
+ styleOutputPath = path;
+}
+
+const string& CodeGenerator::getStyleInputPath(){
+ return styleInputPath;
+}
+const string& CodeGenerator::getStyleOutputPath(){
+ return styleOutputPath;
+}
+
+
+bool CodeGenerator::getFragmentCode(){
+ return fragmentOutput;
+}
+
+void CodeGenerator::setStyleName(const string& s){
+ stylePath=s;
+}
+
+void CodeGenerator::setType(OutputType t){
+ outputType = t;
+}
+
+const string& CodeGenerator::getStyleName(){
+ return stylePath;
+}
+
+bool CodeGenerator::formattingDisabled(){
+ return !formattingEnabled;
+}
+
+bool CodeGenerator::formattingIsPossible(){
+ return formattingPossible;
+}
+
+void CodeGenerator::setPreformatting(WrapMode lineWrappingStyle,
+ unsigned int lineLength,
+ int numberSpaces ){
+ bool enableWrap = lineWrappingStyle!=WRAP_DISABLED;
+ bool replaceTabs = numberSpaces > 0;
+ if (enableWrap || replaceTabs) {
+ preFormatter=new PreFormatter(enableWrap, replaceTabs);
+ if (enableWrap)
+ preFormatter->setWrappingProperties(lineLength, lineWrappingStyle==WRAP_DEFAULT);
+ if (replaceTabs)
+ preFormatter->setNumberSpaces(numberSpaces);
+ }
+}
+
+/*
+WrapMode CodeGenerator::getLineWrapping(){
+ if (preFormatter==NULL) return WRAP_DISABLED;
+ return (preFormatter->indentCode()?WRAP_DEFAULT:WRAP_SIMPLE);
+}
+*/
+LanguageDefinition &CodeGenerator::getLanguage(){
+ return langInfo;
+}
+
+void CodeGenerator::reset()
+{
+ lineIndex = lineNumber = 0;
+ line.clear();
+}
+
+
+/** sucht vorwaerts ab Position searchPos Ziffer in s und liefert Integerwert
+der gefundenen Zahl zurueck.
+Im SymbolString stehen die den einzelnen Symbolen zugeordneten Konstanten
+immer HINTER diesen Symbolen*/
+State CodeGenerator::getState(const string &s, unsigned int searchPos)
+{
+ unsigned int i= searchPos+1, result=0;
+
+ // nach Ziffer in s suchen
+ do {
+ ++i;
+ } while ((i<s.length()) && !isdigit(s[i])) ;
+
+ // Zahl zusammensetzen
+ while ((i<s.length()) && isdigit(s[i])){
+ result = result *10 + (s[i]-'0');
+ ++i;
+ }
+ return ((result)? (State)result:_UNKNOWN);
+}
+
+string CodeGenerator::getIdentifier()
+{
+ --lineIndex;
+ unsigned int startPos=lineIndex;
+ char c= line[lineIndex];
+
+ while ( ( lineIndex < line.length()
+ && ( StringTools::isAlpha(c)
+ || isdigit(c))
+ || isAllowedChar(c))
+ )
+ {
+ ++lineIndex;
+ c= line[lineIndex];
+ }
+ return string(line, startPos, lineIndex - startPos);
+}
+
+string CodeGenerator::getNumber()
+{
+ --lineIndex;
+ unsigned int startPos=lineIndex;
+ char c=line[lineIndex];
+
+ while ( lineIndex < line.length() && (
+ isdigit(c)
+ // don't highlight methods applied on numbers as part of the number
+ // i.e. Ruby: 3.xxx()
+ || (c == '.' && isdigit(line[lineIndex+1]))
+ // '-' is accepted as first character
+ || (c == '-' && lineIndex == startPos)
+ || (StringTools::isAlpha(c) && line[lineIndex-1]=='0')
+ || (isxdigit(c) || c=='L' || c=='U' || c=='l' || c=='u') ))
+ {
+ ++lineIndex;
+ c= line[lineIndex];
+ }
+ return string(line,startPos, lineIndex-startPos);
+}
+
+unsigned int CodeGenerator::getLineNumber()
+{
+ return lineNumber;
+}
+
+bool CodeGenerator::readNewLine(string &newLine){
+ bool eof;
+ terminatingChar=newLine[lineIndex-1];
+ if (formattingPossible && formattingEnabled)
+ {
+ eof=!formatter->hasMoreLines();
+ if (!eof)
+ {
+ newLine = formatter->nextLine();
+ }
+ }
+ else // reformatting not enabled
+ {
+ eof = ! getline( *in, newLine);
+ }
+ return eof;
+}
+
+unsigned char CodeGenerator::getInputChar()
+{
+ bool eol = lineIndex == line.length();
+
+ if (eol) {
+ bool eof=false;
+ if (preFormatter!=NULL){
+ if (!preFormatter->hasMoreLines()) {
+ eof=readNewLine(line);
+ preFormatter->setLine(line);
+ }
+ line = preFormatter->getNextLine();
+ } else {
+ eof=readNewLine(line);
+ }
+ lineIndex=0;
+ ++lineNumber;
+ line=StringTools::trimRight(line);
+ return (eof)?'\0':'\n';
+ }
+ return line[lineIndex++];
+}
+
+State CodeGenerator::getCurrentState (bool lastStateWasNumber)
+{
+ unsigned char c;
+
+ if (token.length()==0) {
+ c=getInputChar();
+ } else {
+ lineIndex-= (token.length()-1);
+ c=token[0];
+ }
+ if (c=='\n'){
+ return _EOL; // End of line
+ }
+
+ if (c=='\0') {
+ return _EOF; // End of file
+ }
+
+ if (isspace(c)) {
+ token= c;
+ return _WS;
+ }
+
+ // numbers have to be searched before using the symbolstring,
+ // as numbers are part of this string
+ if (isdigit(c)
+ // recognize floats like .5
+ || (c=='.' && isdigit(line[lineIndex]))
+ // test if '-' belongs to a term like "1-2"
+ || ((c == '-')
+ && (!lastStateWasNumber)
+ && isdigit(StringTools::getNextNonWs(line, lineIndex))) )
+ {
+ token = getNumber();
+ return NUMBER;
+ }
+ unsigned int symbolLength;
+ size_t symbolPos;
+ bool found=false;
+ string symbols=langInfo.getSymbolString();
+
+ symbolPos = symbols.find(c);
+ // search symbols (comment delimiters, directives etc.)
+ // before keywords, because alphabetic chars may be part of symbols, too
+ while ((symbolPos!= string::npos) && (!found))
+ {
+ symbolLength=symbols.find(' ', symbolPos)-symbolPos;
+ token = symbols.substr(symbolPos, symbolLength);
+
+ // TODO Ruby =ende, =end bugfix (whitespace after symbol needs to be checked)
+
+ // Abfrage nach Leerzeichen in SymbolString verhindert falsches
+ // Erkennen von Symbolteilen:
+ if (lineIndex && token == line.substr(lineIndex-1, symbolLength)
+ && isspace(symbols[symbolPos-1]) ) {
+ found = true;
+ lineIndex += (symbolLength-1);
+ } else {
+ symbolPos = symbols.find_first_not_of(' ',symbols.find(' ',symbolPos));
+ }
+ }
+
+ // dirty workaround stuff in here
+ if (found) {
+ State foundState = getState(symbols, symbolPos);
+
+ // get the current keyword class id to apply the corresponding formatting style
+ if (foundState==KEYWORD_BEGIN || foundState==TAG_BEGIN ) {
+ currentKeywordClass=langInfo.getDelimPrefixClassID(token);
+ }
+
+ // Full line quotes must start in coloumn 1 (Fortran 77)
+ if (langInfo.isFullLineComment() && foundState==SL_COMMENT){
+ if (lineIndex==1) {
+ return SL_COMMENT;
+ }
+ }
+ // VHDL Workaround: distinguish string delimiters and event markers
+ // (same eymbol: ')
+ else if (langInfo.isVHDL()
+ && foundState==STRING && currentState!=STRING
+ && lineIndex > 1
+ &&(isdigit(line[lineIndex-2]) || isalpha(line[lineIndex-2]))){
+ c=line[lineIndex-1];
+ // do not return, continue search...
+ } else {
+ return foundState;
+ }
+ }
+
+ // Alphanumerisches Token parsen und als Keyword oder Type erkennen
+ if (StringTools::isAlpha(c) || langInfo.isPrefix(c) || isAllowedChar(c))
+ {
+ if (langInfo.isPrefix(c)){
+ token = c;
+ ++lineIndex;
+ token += getIdentifier();
+ } else {
+ token = getIdentifier();
+ }
+ string reservedWord=(langInfo.isIgnoreCase()) ?
+ StringTools::lowerCase(token):token;
+ currentKeywordClass=langInfo.isKeyword(reservedWord);
+ return (currentKeywordClass) ? KEYWORD : STANDARD;
+ }
+
+ // Character not referring to any state
+ token = c;
+ return STANDARD;
+}
+
+string CodeGenerator::maskString(const string & s)
+{
+ ostringstream ss;
+ for (unsigned int i=0;i< s.length();i++){
+ ss << maskCharacter(s[i]);
+ }
+ return ss.str();
+}
+
+void CodeGenerator::printMaskedToken(bool flushWhiteSpace)
+{
+ if(flushWhiteSpace) flushWs();
+ *out << maskString(token);
+ token.clear();
+}
+
+bool CodeGenerator::isAllowedChar(char c)
+{
+ return ( langInfo.getAllowedChars().find(c)!= string::npos);
+}
+
+bool CodeGenerator::styleFound(){
+ return docStyle.found();
+}
+
+bool CodeGenerator::printIndexFile(const vector<string> &fileList,
+ const string &outPath){
+ return true;
+}
+
+bool CodeGenerator::initIndentationScheme(const string &schemePath){
+
+ if (formatter!=NULL){
+ return true;
+ }
+
+ ConfigurationReader indentScheme(schemePath);
+ if (indentScheme.found()){
+ if (formatter==NULL) {
+ formatter=new astyle::ASFormatter();
+
+ string brackets=indentScheme.getParameter("brackets");
+ if (!brackets.empty()){
+ // Break brackets from pre-block code (i.e. ANSI C/C++ style).
+ if (brackets=="break"){
+ formatter->setBracketFormatMode(astyle::BREAK_MODE);
+ }
+ //Attach brackets to pre-block code (i.e. Java/K&R style).
+ else if (brackets=="attach"){
+ formatter->setBracketFormatMode(astyle::ATTACH_MODE);
+ }
+ // Break definition-block brackets and attach command-block brackets.
+ else if (brackets=="linux"){
+ formatter->setBracketFormatMode(astyle::BDAC_MODE);
+ }
+ // Break brackets before closing headers (e.g. 'else', 'catch', ..).
+ // Should be appended to --brackets=attach or --brackets=linux.
+ else if (brackets=="break-closing-headers"){
+ formatter->setBreakClosingHeaderBracketsMode(true);
+ }
+ }
+
+ string pad=indentScheme.getParameter("pad");
+ if (!pad.empty()){
+ //Insert space paddings around parenthesies only.
+ if (pad=="paren"){
+ formatter->setParenthesisPaddingMode(true);
+ }
+ // Insert space paddings around operators only.
+ else if (pad=="oper"){
+ formatter->setOperatorPaddingMode(true);
+ }
+ //Insert space paddings around operators AND parenthesies.
+ else if (pad=="all"){
+ formatter->setOperatorPaddingMode(true);
+ formatter->setParenthesisPaddingMode(true);
+ }
+ }
+
+ string oneLine=indentScheme.getParameter("one-line");
+ if (!oneLine.empty()){
+ // Don't break one-line blocks.
+ if (oneLine=="keep-blocks"){
+ formatter->setBreakOneLineBlocksMode(false);
+ }
+ // Don't break complex statements and multiple statements residing in a
+ // single line.
+ else if (oneLine=="keep-statements"){
+ formatter->setSingleStatementsMode(false);
+ }
+ }
+
+ // Insert empty lines around unrelated blocks, labels, classes, ...
+ string breakBlocks=indentScheme.getParameter("break-blocks");
+ if (!breakBlocks.empty()){
+ if (breakBlocks=="all"){
+ //Like --break-blocks, except also insert empty lines around closing
+ //headers (e.g. 'else', 'catch', ...).
+ formatter->setBreakClosingHeaderBlocksMode(true);
+ }
+ formatter->setBreakBlocksMode(true);
+ }
+ string trueVal="true";
+
+ // Other options...
+
+ //Indent using # spaces per indent. Not specifying # will result in a
+ //default of 4 spaces per indent.
+ string indentSpaces=indentScheme.getParameter("indent-spaces");
+
+ // Indent a minimal # spaces in a continuous conditional belonging to a
+ //conditional header.
+ string minConditionalIndent=indentScheme.getParameter("min-conditional-indent");
+
+ // Indent a maximal # spaces in a continuous statement, relatively to the
+ // previous line.
+ string maxInStatementIndent=indentScheme.getParameter("max-instatement-indent");
+
+ // Add extra indentation to '{' and '}' block brackets.
+ string indentBrackets=indentScheme.getParameter("indent-brackets");
+
+ // Add extra indentation entire blocks (including brackets).
+ string indentBlocks=indentScheme.getParameter("indent-blocks");
+
+ // Indent the contents of namespace blocks.
+ string indentNamespaces=indentScheme.getParameter("indent-namespaces");
+
+ // Indent 'class' blocks, so that the inner 'public:','protected:' and
+ // 'private: headers are indented inrelation to the class block.
+ string indentClasses=indentScheme.getParameter("indent-classes");
+
+ // Indent 'switch' blocks, so that the inner 'case XXX:' headers are
+ // indented in relation to the switch block.
+ string indentSwitches=indentScheme.getParameter("indent-switches");
+
+ // Indent 'case XXX:' lines, so that they are flush with their bodies..
+ string indentCases=indentScheme.getParameter("indent-cases");
+
+ // Indent labels so that they appear one indent less than the current
+ // indentation level, rather than being flushed completely to the left
+ // (which is the default).
+ string indentLabels=indentScheme.getParameter("indent-labels");
+
+ // Indent multi-line #define statements
+ string indentPreprocessor=indentScheme.getParameter("indent-preprocessor");
+
+ // Break 'else if()' statements into two different lines.
+ string breakElseIfs = indentScheme.getParameter("break-elseifs");
+
+ string javaStyle = indentScheme.getParameter("java-style");
+
+ // default values in ASBeautifier are false, it is ok to set them false
+ // if parameter does not exist in scheme file
+ formatter->setBracketIndent(indentBrackets==trueVal);
+ formatter->setBlockIndent(indentBlocks==trueVal);
+ formatter->setNamespaceIndent(indentNamespaces==trueVal);
+ formatter->setClassIndent(indentClasses==trueVal);
+ formatter->setSwitchIndent(indentSwitches==trueVal);
+ formatter->setCaseIndent(indentCases==trueVal);
+ formatter->setLabelIndent(indentLabels==trueVal);
+ formatter->setPreprocessorIndent(indentPreprocessor==trueVal);
+ formatter->setBreakElseIfsMode(breakElseIfs==trueVal);
+
+ if (javaStyle==trueVal){
+ formatter->setJavaStyle();
+ }
+
+ if (!indentSpaces.empty()){
+ formatter->setSpaceIndentation(StringTools::str2int(indentSpaces));
+ }
+ if (!minConditionalIndent.empty()){
+ formatter->setMinConditionalIndentLength(
+ StringTools::str2int(minConditionalIndent));
+ }
+ if (!maxInStatementIndent.empty()){
+ formatter->setMinConditionalIndentLength(
+ StringTools::str2int(maxInStatementIndent));
+ }
+ }
+ formattingEnabled=(formatter != NULL);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+LoadResult CodeGenerator::initLanguage(const string& langDefPath){
+ bool reloadNecessary= langInfo.needsReload(langDefPath);
+ if (reloadNecessary){
+ bool failure = !langInfo.load(langDefPath);
+
+ if (failure) {
+ return LOAD_FAILED;
+ }
+
+ formattingPossible=langInfo.enableReformatting();
+
+ if (styleTagOpen.size()>NUMBER_BUILTIN_STYLES){
+ // remove dynamic keyword tag delimiters of the old language definition
+ vector<string>::iterator keyStyleOpenBegin =
+ styleTagOpen.begin() + NUMBER_BUILTIN_STYLES;
+ vector<string>::iterator keyStyleCloseBegin =
+ styleTagClose.begin()+ NUMBER_BUILTIN_STYLES;
+ styleTagOpen.erase(keyStyleOpenBegin, styleTagOpen.end());
+ styleTagClose.erase(keyStyleCloseBegin, styleTagClose.end());
+ }
+ // add new keyword delimiters
+ for (unsigned int i=0;i< langInfo.getKeywordClasses().size(); i++){
+ styleTagOpen.push_back(getMatchingOpenTag(i));
+ styleTagClose.push_back(getMatchingCloseTag(i));
+ }
+ }
+ return (reloadNecessary) ? LOAD_NEW : LOAD_NONE;
+}
+
+ParseError CodeGenerator::printOutput (const string & inFileName,
+ const string &outFileName)
+{
+ if (!docStyle.found()) {
+ return BAD_STYLE;
+ }
+ reset();
+
+ ParseError error=PARSE_OK;
+
+ in = (inFileName.empty()? &cin :new ifstream (inFileName.c_str()));
+ if (!in->fail()) {
+ out = (outFileName.empty()? &cout :new ofstream (outFileName.c_str()));
+ if ( out->fail()) {
+ error=BAD_OUTPUT;
+ }
+ }
+
+ if ( in->fail()){
+ error=BAD_INPUT;
+ }
+
+ if (error==PARSE_OK) {
+ if (formatter != NULL){
+ formatter->init(new astyle::ASStreamIterator(in));
+ }
+ if (! fragmentOutput){
+ *out << getHeader(inFileName);
+ }
+ printBody();
+ if (! fragmentOutput){
+ *out << getFooter();
+ }
+ }
+
+ if (!outFileName.empty()){
+ delete out; out=NULL;
+ }
+ if (!inFileName.empty()) {
+ delete in; in=NULL;
+ }
+ return error;
+}
+
+
+unsigned int CodeGenerator::getStyleID(State s, unsigned int kwClassID){
+ if (s==KEYWORD && kwClassID){
+ return NUMBER_BUILTIN_STYLES + kwClassID-1;
+ }
+ return (unsigned int) s ;
+}
+
+void CodeGenerator::closeTag(State s){
+ *out << styleTagClose[(unsigned int)s];
+ flushWs();
+ currentState=_UNKNOWN;
+}
+
+void CodeGenerator::openTag(State s){
+ *out << styleTagOpen[(unsigned int)s];
+ currentState=s;
+}
+
+void CodeGenerator::closeKWTag(unsigned int kwClassID){
+ *out << styleTagClose[getStyleID(KEYWORD, kwClassID)];
+
+ flushWs();
+ currentState=_UNKNOWN;
+}
+
+void CodeGenerator::openKWTag(unsigned int kwClassID){
+ *out << styleTagOpen[getStyleID(KEYWORD, 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 "&lt;";
+ break;
+ case '>' :
+ return "&gt;";
+ break;
+ case '&' :
+ return "&amp;";
+ break;
+ case '\"' :
+ return "&quot;";
+ break;
+
+ case '@' :
+ return "&#64;";
+ 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 "&lt;";
+ break;
+ case '>' :
+ return "&gt;";
+ break;
+ case '&' :
+ return "&amp;";
+ break;
+ case '\"' :
+ return "&quot;";
+ 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 "&lt;";
+ break;
+ case '>' :
+ return "&gt;";
+ break;
+ case '&' :
+ return "&amp;";
+ break;
+ case '\"' :
+ return "&quot;";
+ 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
View Lorry Controller Status