use custom astyle
This commit is contained in:
Roy Qu
parent
400764f2aa
commit
158155d539
|
|
@ -2827,10 +2827,9 @@ void Settings::Environment::doLoad()
|
|||
if (!fileExists(mDefaultOpenFolder)) {
|
||||
mDefaultOpenFolder = QDir::currentPath();
|
||||
}
|
||||
|
||||
#ifdef Q_OS_LINUX
|
||||
mTerminalPath = stringValue("terminal_path","/usr/bin/x-terminal-emulator");
|
||||
mAStylePath = stringValue("asyle_path","/usr/bin/astyle");
|
||||
mAStylePath = includeTrailingPathDelimiter(pSettings->dirs().appDir())+"astyle";
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ TEMPLATE = subdirs
|
|||
|
||||
SUBDIRS += \
|
||||
RedPandaIDE \
|
||||
astyle \
|
||||
consolepauser
|
||||
|
||||
APP_NAME = RedPandaIDE
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,775 @@
|
|||
// ASEnhancer.cpp
|
||||
// Copyright (c) 2018 by Jim Pattee <jimp03@email.com>.
|
||||
// This code is licensed under the MIT License.
|
||||
// License.md describes the conditions under which this software may be distributed.
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// headers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "astyle.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// astyle namespace
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace astyle {
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
// ASEnhancer class
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* initialize the ASEnhancer.
|
||||
*
|
||||
* init() is called each time an ASFormatter object is initialized.
|
||||
*/
|
||||
void ASEnhancer::init(int _fileType,
|
||||
int _indentLength,
|
||||
int _tabLength,
|
||||
bool _useTabs,
|
||||
bool _forceTab,
|
||||
bool _namespaceIndent,
|
||||
bool _caseIndent,
|
||||
bool _preprocBlockIndent,
|
||||
bool _preprocDefineIndent,
|
||||
bool _emptyLineFill,
|
||||
vector<const pair<const string, const string>* >* _indentableMacros)
|
||||
{
|
||||
// formatting variables from ASFormatter and ASBeautifier
|
||||
ASBase::init(_fileType);
|
||||
indentLength = _indentLength;
|
||||
tabLength = _tabLength;
|
||||
useTabs = _useTabs;
|
||||
forceTab = _forceTab;
|
||||
namespaceIndent = _namespaceIndent;
|
||||
caseIndent = _caseIndent;
|
||||
preprocBlockIndent = _preprocBlockIndent;
|
||||
preprocDefineIndent = _preprocDefineIndent;
|
||||
emptyLineFill = _emptyLineFill;
|
||||
indentableMacros = _indentableMacros;
|
||||
quoteChar = '\'';
|
||||
|
||||
// unindent variables
|
||||
lineNumber = 0;
|
||||
braceCount = 0;
|
||||
isInComment = false;
|
||||
isInQuote = false;
|
||||
switchDepth = 0;
|
||||
eventPreprocDepth = 0;
|
||||
lookingForCaseBrace = false;
|
||||
unindentNextLine = false;
|
||||
shouldUnindentLine = false;
|
||||
shouldUnindentComment = false;
|
||||
|
||||
// switch struct and vector
|
||||
sw.switchBraceCount = 0;
|
||||
sw.unindentDepth = 0;
|
||||
sw.unindentCase = false;
|
||||
switchStack.clear();
|
||||
|
||||
// other variables
|
||||
nextLineIsEventIndent = false;
|
||||
isInEventTable = false;
|
||||
nextLineIsDeclareIndent = false;
|
||||
isInDeclareSection = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* additional formatting for line of source code.
|
||||
* every line of source code in a source code file should be sent
|
||||
* one after the other to this function.
|
||||
* indents event tables
|
||||
* unindents the case blocks
|
||||
*
|
||||
* @param line the original formatted line will be updated if necessary.
|
||||
*/
|
||||
void ASEnhancer::enhance(string& line, bool isInNamespace, bool isInPreprocessor, bool isInSQL)
|
||||
{
|
||||
shouldUnindentLine = true;
|
||||
shouldUnindentComment = false;
|
||||
lineNumber++;
|
||||
|
||||
// check for beginning of event table
|
||||
if (nextLineIsEventIndent)
|
||||
{
|
||||
isInEventTable = true;
|
||||
nextLineIsEventIndent = false;
|
||||
}
|
||||
|
||||
// check for beginning of SQL declare section
|
||||
if (nextLineIsDeclareIndent)
|
||||
{
|
||||
isInDeclareSection = true;
|
||||
nextLineIsDeclareIndent = false;
|
||||
}
|
||||
|
||||
if (line.length() == 0
|
||||
&& !isInEventTable
|
||||
&& !isInDeclareSection
|
||||
&& !emptyLineFill)
|
||||
return;
|
||||
|
||||
// test for unindent on attached braces
|
||||
if (unindentNextLine)
|
||||
{
|
||||
sw.unindentDepth++;
|
||||
sw.unindentCase = true;
|
||||
unindentNextLine = false;
|
||||
}
|
||||
|
||||
// parse characters in the current line
|
||||
parseCurrentLine(line, isInPreprocessor, isInSQL);
|
||||
|
||||
// check for SQL indentable lines
|
||||
if (isInDeclareSection)
|
||||
{
|
||||
size_t firstText = line.find_first_not_of(" \t");
|
||||
if (firstText == string::npos || line[firstText] != '#')
|
||||
indentLine(line, 1);
|
||||
}
|
||||
|
||||
// check for event table indentable lines
|
||||
if (isInEventTable
|
||||
&& (eventPreprocDepth == 0
|
||||
|| (namespaceIndent && isInNamespace)))
|
||||
{
|
||||
size_t firstText = line.find_first_not_of(" \t");
|
||||
if (firstText == string::npos || line[firstText] != '#')
|
||||
indentLine(line, 1);
|
||||
}
|
||||
|
||||
if (shouldUnindentComment && sw.unindentDepth > 0)
|
||||
unindentLine(line, sw.unindentDepth - 1);
|
||||
else if (shouldUnindentLine && sw.unindentDepth > 0)
|
||||
unindentLine(line, sw.unindentDepth);
|
||||
}
|
||||
|
||||
/**
|
||||
* convert a force-tab indent to spaces
|
||||
*
|
||||
* @param line a reference to the line that will be converted.
|
||||
*/
|
||||
void ASEnhancer::convertForceTabIndentToSpaces(string& line) const
|
||||
{
|
||||
// replace tab indents with spaces
|
||||
for (size_t i = 0; i < line.length(); i++)
|
||||
{
|
||||
if (!isWhiteSpace(line[i]))
|
||||
break;
|
||||
if (line[i] == '\t')
|
||||
{
|
||||
line.erase(i, 1);
|
||||
line.insert(i, tabLength, ' ');
|
||||
i += tabLength - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* convert a space indent to force-tab
|
||||
*
|
||||
* @param line a reference to the line that will be converted.
|
||||
*/
|
||||
void ASEnhancer::convertSpaceIndentToForceTab(string& line) const
|
||||
{
|
||||
assert(tabLength > 0);
|
||||
|
||||
// replace leading spaces with tab indents
|
||||
size_t newSpaceIndentLength = line.find_first_not_of(" \t");
|
||||
size_t tabCount = newSpaceIndentLength / tabLength; // truncate extra spaces
|
||||
line.replace(0U, tabCount * tabLength, tabCount, '\t');
|
||||
}
|
||||
|
||||
/**
|
||||
* find the colon following a 'case' statement
|
||||
*
|
||||
* @param line a reference to the line.
|
||||
* @param caseIndex the line index of the case statement.
|
||||
* @return the line index of the colon.
|
||||
*/
|
||||
size_t ASEnhancer::findCaseColon(const string& line, size_t caseIndex) const
|
||||
{
|
||||
size_t i = caseIndex;
|
||||
bool isInQuote_ = false;
|
||||
char quoteChar_ = ' ';
|
||||
for (; i < line.length(); i++)
|
||||
{
|
||||
if (isInQuote_)
|
||||
{
|
||||
if (line[i] == '\\')
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (line[i] == quoteChar_) // check ending quote
|
||||
{
|
||||
isInQuote_ = false;
|
||||
quoteChar_ = ' ';
|
||||
continue;
|
||||
}
|
||||
continue; // must close quote before continuing
|
||||
}
|
||||
if (line[i] == '"' // check opening quote
|
||||
|| (line[i] == '\'' && !isDigitSeparator(line, i)))
|
||||
{
|
||||
isInQuote_ = true;
|
||||
quoteChar_ = line[i];
|
||||
continue;
|
||||
}
|
||||
if (line[i] == ':')
|
||||
{
|
||||
if ((i + 1 < line.length()) && (line[i + 1] == ':'))
|
||||
i++; // bypass scope resolution operator
|
||||
else
|
||||
break; // found it
|
||||
}
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
/**
|
||||
* indent a line by a given number of tabsets
|
||||
* by inserting leading whitespace to the line argument.
|
||||
*
|
||||
* @param line a reference to the line to indent.
|
||||
* @param indent the number of tabsets to insert.
|
||||
* @return the number of characters inserted.
|
||||
*/
|
||||
int ASEnhancer::indentLine(string& line, int indent) const
|
||||
{
|
||||
if (line.length() == 0
|
||||
&& !emptyLineFill)
|
||||
return 0;
|
||||
|
||||
size_t charsToInsert = 0;
|
||||
|
||||
if (forceTab && indentLength != tabLength)
|
||||
{
|
||||
// replace tab indents with spaces
|
||||
convertForceTabIndentToSpaces(line);
|
||||
// insert the space indents
|
||||
charsToInsert = indent * indentLength;
|
||||
line.insert(line.begin(), charsToInsert, ' ');
|
||||
// replace leading spaces with tab indents
|
||||
convertSpaceIndentToForceTab(line);
|
||||
}
|
||||
else if (useTabs)
|
||||
{
|
||||
charsToInsert = indent;
|
||||
line.insert(line.begin(), charsToInsert, '\t');
|
||||
}
|
||||
else // spaces
|
||||
{
|
||||
charsToInsert = indent * indentLength;
|
||||
line.insert(line.begin(), charsToInsert, ' ');
|
||||
}
|
||||
|
||||
return charsToInsert;
|
||||
}
|
||||
|
||||
/**
|
||||
* check for SQL "BEGIN DECLARE SECTION".
|
||||
* must compare case insensitive and allow any spacing between words.
|
||||
*
|
||||
* @param line a reference to the line to indent.
|
||||
* @param index the current line index.
|
||||
* @return true if a hit.
|
||||
*/
|
||||
bool ASEnhancer::isBeginDeclareSectionSQL(const string& line, size_t index) const
|
||||
{
|
||||
string word;
|
||||
size_t hits = 0;
|
||||
size_t i;
|
||||
for (i = index; i < line.length(); i++)
|
||||
{
|
||||
i = line.find_first_not_of(" \t", i);
|
||||
if (i == string::npos)
|
||||
return false;
|
||||
if (line[i] == ';')
|
||||
break;
|
||||
if (!isCharPotentialHeader(line, i))
|
||||
continue;
|
||||
word = getCurrentWord(line, i);
|
||||
for (char& character : word)
|
||||
character = (char) toupper(character);
|
||||
if (word == "EXEC" || word == "SQL")
|
||||
{
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
if (word == "DECLARE" || word == "SECTION")
|
||||
{
|
||||
hits++;
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
if (word == "BEGIN")
|
||||
{
|
||||
hits++;
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (hits == 3)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* check for SQL "END DECLARE SECTION".
|
||||
* must compare case insensitive and allow any spacing between words.
|
||||
*
|
||||
* @param line a reference to the line to indent.
|
||||
* @param index the current line index.
|
||||
* @return true if a hit.
|
||||
*/
|
||||
bool ASEnhancer::isEndDeclareSectionSQL(const string& line, size_t index) const
|
||||
{
|
||||
string word;
|
||||
size_t hits = 0;
|
||||
size_t i;
|
||||
for (i = index; i < line.length(); i++)
|
||||
{
|
||||
i = line.find_first_not_of(" \t", i);
|
||||
if (i == string::npos)
|
||||
return false;
|
||||
if (line[i] == ';')
|
||||
break;
|
||||
if (!isCharPotentialHeader(line, i))
|
||||
continue;
|
||||
word = getCurrentWord(line, i);
|
||||
for (char& character : word)
|
||||
character = (char) toupper(character);
|
||||
if (word == "EXEC" || word == "SQL")
|
||||
{
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
if (word == "DECLARE" || word == "SECTION")
|
||||
{
|
||||
hits++;
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
if (word == "END")
|
||||
{
|
||||
hits++;
|
||||
i += word.length() - 1;
|
||||
continue;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (hits == 3)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* check if a one-line brace has been reached,
|
||||
* i.e. if the currently reached '{' character is closed
|
||||
* with a complimentary '}' elsewhere on the current line,
|
||||
*.
|
||||
* @return false = one-line brace has not been reached.
|
||||
* true = one-line brace has been reached.
|
||||
*/
|
||||
bool ASEnhancer::isOneLineBlockReached(const string& line, int startChar) const
|
||||
{
|
||||
assert(line[startChar] == '{');
|
||||
|
||||
bool isInComment_ = false;
|
||||
bool isInQuote_ = false;
|
||||
int _braceCount = 1;
|
||||
int lineLength = line.length();
|
||||
char quoteChar_ = ' ';
|
||||
char ch = ' ';
|
||||
|
||||
for (int i = startChar + 1; i < lineLength; ++i)
|
||||
{
|
||||
ch = line[i];
|
||||
|
||||
if (isInComment_)
|
||||
{
|
||||
if (line.compare(i, 2, "*/") == 0)
|
||||
{
|
||||
isInComment_ = false;
|
||||
++i;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ch == '\\')
|
||||
{
|
||||
++i;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isInQuote_)
|
||||
{
|
||||
if (ch == quoteChar_)
|
||||
isInQuote_ = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ch == '"'
|
||||
|| (ch == '\'' && !isDigitSeparator(line, i)))
|
||||
{
|
||||
isInQuote_ = true;
|
||||
quoteChar_ = ch;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (line.compare(i, 2, "//") == 0)
|
||||
break;
|
||||
|
||||
if (line.compare(i, 2, "/*") == 0)
|
||||
{
|
||||
isInComment_ = true;
|
||||
++i;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ch == '{')
|
||||
++_braceCount;
|
||||
else if (ch == '}')
|
||||
--_braceCount;
|
||||
|
||||
if (_braceCount == 0)
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* parse characters in the current line to determine if an indent
|
||||
* or unindent is needed.
|
||||
*/
|
||||
void ASEnhancer::parseCurrentLine(string& line, bool isInPreprocessor, bool isInSQL)
|
||||
{
|
||||
bool isSpecialChar = false; // is a backslash escape character
|
||||
|
||||
for (size_t i = 0; i < line.length(); i++)
|
||||
{
|
||||
char ch = line[i];
|
||||
|
||||
// bypass whitespace
|
||||
if (isWhiteSpace(ch))
|
||||
continue;
|
||||
|
||||
// handle special characters (i.e. backslash+character such as \n, \t, ...)
|
||||
if (isSpecialChar)
|
||||
{
|
||||
isSpecialChar = false;
|
||||
continue;
|
||||
}
|
||||
if (!(isInComment) && line.compare(i, 2, "\\\\") == 0)
|
||||
{
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (!(isInComment) && ch == '\\')
|
||||
{
|
||||
isSpecialChar = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// handle quotes (such as 'x' and "Hello Dolly")
|
||||
if (!isInComment
|
||||
&& (ch == '"'
|
||||
|| (ch == '\'' && !isDigitSeparator(line, i))))
|
||||
{
|
||||
if (!isInQuote)
|
||||
{
|
||||
quoteChar = ch;
|
||||
isInQuote = true;
|
||||
}
|
||||
else if (quoteChar == ch)
|
||||
{
|
||||
isInQuote = false;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (isInQuote)
|
||||
continue;
|
||||
|
||||
// handle comments
|
||||
|
||||
if (!(isInComment) && line.compare(i, 2, "//") == 0)
|
||||
{
|
||||
// check for windows line markers
|
||||
if (line.compare(i + 2, 1, "\xf0") > 0)
|
||||
lineNumber--;
|
||||
// unindent if not in case braces
|
||||
if (line.find_first_not_of(" \t") == i
|
||||
&& sw.switchBraceCount == 1
|
||||
&& sw.unindentCase)
|
||||
shouldUnindentComment = true;
|
||||
break; // finished with the line
|
||||
}
|
||||
if (!(isInComment) && line.compare(i, 2, "/*") == 0)
|
||||
{
|
||||
// unindent if not in case braces
|
||||
if (sw.switchBraceCount == 1 && sw.unindentCase)
|
||||
shouldUnindentComment = true;
|
||||
isInComment = true;
|
||||
size_t commentEnd = line.find("*/", i);
|
||||
if (commentEnd == string::npos)
|
||||
i = line.length() - 1;
|
||||
else
|
||||
i = commentEnd - 1;
|
||||
continue;
|
||||
}
|
||||
if ((isInComment) && line.compare(i, 2, "*/") == 0)
|
||||
{
|
||||
// unindent if not in case braces
|
||||
if (sw.switchBraceCount == 1 && sw.unindentCase)
|
||||
shouldUnindentComment = true;
|
||||
isInComment = false;
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (isInComment)
|
||||
{
|
||||
// unindent if not in case braces
|
||||
if (sw.switchBraceCount == 1 && sw.unindentCase)
|
||||
shouldUnindentComment = true;
|
||||
size_t commentEnd = line.find("*/", i);
|
||||
if (commentEnd == string::npos)
|
||||
i = line.length() - 1;
|
||||
else
|
||||
i = commentEnd - 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
// if we have reached this far then we are NOT in a comment or string of special characters
|
||||
|
||||
if (line[i] == '{')
|
||||
braceCount++;
|
||||
|
||||
if (line[i] == '}')
|
||||
braceCount--;
|
||||
|
||||
// check for preprocessor within an event table
|
||||
if (isInEventTable && line[i] == '#' && preprocBlockIndent)
|
||||
{
|
||||
string preproc;
|
||||
preproc = line.substr(i + 1);
|
||||
if (preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef)
|
||||
eventPreprocDepth += 1;
|
||||
if (preproc.substr(0, 5) == "endif" && eventPreprocDepth > 0)
|
||||
eventPreprocDepth -= 1;
|
||||
}
|
||||
|
||||
bool isPotentialKeyword = isCharPotentialHeader(line, i);
|
||||
|
||||
// ---------------- wxWidgets and MFC macros ----------------------------------
|
||||
|
||||
if (isPotentialKeyword)
|
||||
{
|
||||
for (const auto* indentableMacro : *indentableMacros)
|
||||
{
|
||||
// 'first' is the beginning macro
|
||||
if (findKeyword(line, i, indentableMacro->first))
|
||||
{
|
||||
nextLineIsEventIndent = true;
|
||||
break;
|
||||
}
|
||||
// 'second' is the ending macro
|
||||
if (findKeyword(line, i, indentableMacro->second))
|
||||
{
|
||||
isInEventTable = false;
|
||||
eventPreprocDepth = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- process SQL -----------------------------------------------
|
||||
|
||||
if (isInSQL)
|
||||
{
|
||||
if (isBeginDeclareSectionSQL(line, i))
|
||||
nextLineIsDeclareIndent = true;
|
||||
if (isEndDeclareSectionSQL(line, i))
|
||||
isInDeclareSection = false;
|
||||
break;
|
||||
}
|
||||
|
||||
// ---------------- process switch statements ---------------------------------
|
||||
|
||||
if (isPotentialKeyword && findKeyword(line, i, ASResource::AS_SWITCH))
|
||||
{
|
||||
switchDepth++;
|
||||
switchStack.emplace_back(sw); // save current variables
|
||||
sw.switchBraceCount = 0;
|
||||
sw.unindentCase = false; // don't clear case until end of switch
|
||||
i += 5; // bypass switch statement
|
||||
continue;
|
||||
}
|
||||
|
||||
// just want unindented case statements from this point
|
||||
|
||||
if (caseIndent
|
||||
|| switchDepth == 0
|
||||
|| (isInPreprocessor && !preprocDefineIndent))
|
||||
{
|
||||
// bypass the entire word
|
||||
if (isPotentialKeyword)
|
||||
{
|
||||
string name = getCurrentWord(line, i);
|
||||
i += name.length() - 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
i = processSwitchBlock(line, i);
|
||||
|
||||
} // end of for loop * end of for loop * end of for loop * end of for loop
|
||||
}
|
||||
|
||||
/**
|
||||
* process the character at the current index in a switch block.
|
||||
*
|
||||
* @param line a reference to the line to indent.
|
||||
* @param index the current line index.
|
||||
* @return the new line index.
|
||||
*/
|
||||
size_t ASEnhancer::processSwitchBlock(string& line, size_t index)
|
||||
{
|
||||
size_t i = index;
|
||||
bool isPotentialKeyword = isCharPotentialHeader(line, i);
|
||||
|
||||
if (line[i] == '{')
|
||||
{
|
||||
sw.switchBraceCount++;
|
||||
if (lookingForCaseBrace) // if 1st after case statement
|
||||
{
|
||||
sw.unindentCase = true; // unindenting this case
|
||||
sw.unindentDepth++;
|
||||
lookingForCaseBrace = false; // not looking now
|
||||
}
|
||||
return i;
|
||||
}
|
||||
lookingForCaseBrace = false; // no opening brace, don't indent
|
||||
|
||||
if (line[i] == '}')
|
||||
{
|
||||
sw.switchBraceCount--;
|
||||
if (sw.switchBraceCount == 0) // if end of switch statement
|
||||
{
|
||||
int lineUnindent = sw.unindentDepth;
|
||||
if (line.find_first_not_of(" \t") == i
|
||||
&& !switchStack.empty())
|
||||
lineUnindent = switchStack[switchStack.size() - 1].unindentDepth;
|
||||
if (shouldUnindentLine)
|
||||
{
|
||||
if (lineUnindent > 0)
|
||||
i -= unindentLine(line, lineUnindent);
|
||||
shouldUnindentLine = false;
|
||||
}
|
||||
switchDepth--;
|
||||
sw = switchStack.back();
|
||||
switchStack.pop_back();
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
if (isPotentialKeyword
|
||||
&& (findKeyword(line, i, ASResource::AS_CASE)
|
||||
|| findKeyword(line, i, ASResource::AS_DEFAULT)))
|
||||
{
|
||||
if (sw.unindentCase) // if unindented last case
|
||||
{
|
||||
sw.unindentCase = false; // stop unindenting previous case
|
||||
sw.unindentDepth--;
|
||||
}
|
||||
|
||||
i = findCaseColon(line, i);
|
||||
|
||||
i++;
|
||||
for (; i < line.length(); i++) // bypass whitespace
|
||||
{
|
||||
if (!isWhiteSpace(line[i]))
|
||||
break;
|
||||
}
|
||||
if (i < line.length())
|
||||
{
|
||||
if (line[i] == '{')
|
||||
{
|
||||
braceCount++;
|
||||
sw.switchBraceCount++;
|
||||
if (!isOneLineBlockReached(line, i))
|
||||
unindentNextLine = true;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
lookingForCaseBrace = true;
|
||||
i--; // need to process this char
|
||||
return i;
|
||||
}
|
||||
if (isPotentialKeyword)
|
||||
{
|
||||
string name = getCurrentWord(line, i); // bypass the entire name
|
||||
i += name.length() - 1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
/**
|
||||
* unindent a line by a given number of tabsets
|
||||
* by erasing the leading whitespace from the line argument.
|
||||
*
|
||||
* @param line a reference to the line to unindent.
|
||||
* @param unindent the number of tabsets to erase.
|
||||
* @return the number of characters erased.
|
||||
*/
|
||||
int ASEnhancer::unindentLine(string& line, int unindent) const
|
||||
{
|
||||
size_t whitespace = line.find_first_not_of(" \t");
|
||||
|
||||
if (whitespace == string::npos) // if line is blank
|
||||
whitespace = line.length(); // must remove padding, if any
|
||||
|
||||
if (whitespace == 0)
|
||||
return 0;
|
||||
|
||||
size_t charsToErase = 0;
|
||||
|
||||
if (forceTab && indentLength != tabLength)
|
||||
{
|
||||
// replace tab indents with spaces
|
||||
convertForceTabIndentToSpaces(line);
|
||||
// remove the space indents
|
||||
size_t spaceIndentLength = line.find_first_not_of(" \t");
|
||||
charsToErase = unindent * indentLength;
|
||||
if (charsToErase <= spaceIndentLength)
|
||||
line.erase(0, charsToErase);
|
||||
else
|
||||
charsToErase = 0;
|
||||
// replace leading spaces with tab indents
|
||||
convertSpaceIndentToForceTab(line);
|
||||
}
|
||||
else if (useTabs)
|
||||
{
|
||||
charsToErase = unindent;
|
||||
if (charsToErase <= whitespace)
|
||||
line.erase(0, charsToErase);
|
||||
else
|
||||
charsToErase = 0;
|
||||
}
|
||||
else // spaces
|
||||
{
|
||||
charsToErase = unindent * indentLength;
|
||||
if (charsToErase <= whitespace)
|
||||
line.erase(0, charsToErase);
|
||||
else
|
||||
charsToErase = 0;
|
||||
}
|
||||
|
||||
return charsToErase;
|
||||
}
|
||||
|
||||
} // end namespace astyle
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,172 @@
|
|||
// ASLocalizer.h
|
||||
// Copyright (c) 2018 by Jim Pattee <jimp03@email.com>.
|
||||
// This code is licensed under the MIT License.
|
||||
// License.md describes the conditions under which this software may be distributed.
|
||||
|
||||
|
||||
#ifndef ASLOCALIZER_H
|
||||
#define ASLOCALIZER_H
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
// library builds do not need ASLocalizer
|
||||
#ifdef ASTYLE_JNI
|
||||
#ifndef ASTYLE_LIB // ASTYLE_LIB must be defined for ASTYLE_JNI
|
||||
#define ASTYLE_LIB
|
||||
#endif
|
||||
#endif // ASTYLE_JNI
|
||||
|
||||
namespace astyle {
|
||||
|
||||
using namespace std;
|
||||
|
||||
#ifndef ASTYLE_LIB
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// ASLocalizer class for console build.
|
||||
// This class encapsulates all language-dependent settings and is a
|
||||
// generalization of the C locale concept.
|
||||
//-----------------------------------------------------------------------------
|
||||
class Translation;
|
||||
|
||||
class ASLocalizer
|
||||
{
|
||||
public: // functions
|
||||
ASLocalizer();
|
||||
virtual ~ASLocalizer();
|
||||
string getLanguageID() const;
|
||||
const Translation* getTranslationClass() const;
|
||||
#ifdef _WIN32
|
||||
void setLanguageFromLCID(size_t lcid);
|
||||
#endif
|
||||
void setLanguageFromName(const char* langID);
|
||||
const char* settext(const char* textIn) const;
|
||||
|
||||
private: // functions
|
||||
void setTranslationClass();
|
||||
|
||||
private: // variables
|
||||
Translation* m_translationClass;// pointer to a polymorphic Translation class
|
||||
string m_langID; // language identifier from the locale
|
||||
string m_subLangID; // sub language identifier, if needed
|
||||
#ifdef _WIN32
|
||||
size_t m_lcid; // LCID of the user locale (Windows only)
|
||||
size_t m_codepage; // active codepage, 65001 = utf-8
|
||||
#endif
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Translation base class.
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class Translation
|
||||
// This base class is inherited by the language translation classes.
|
||||
// Polymorphism is used to call the correct language translator.
|
||||
// This class contains the translation vector and settext translation method.
|
||||
// The language vector is built by the language sub classes.
|
||||
// NOTE: This class must have virtual methods for typeid() to work.
|
||||
// typeid() is used by AStyleTestI18n_Localizer.cpp.
|
||||
{
|
||||
public:
|
||||
Translation();
|
||||
virtual ~Translation() = default;
|
||||
string convertToMultiByte(const wstring& wideStr) const;
|
||||
string getTranslationString(size_t i) const;
|
||||
size_t getTranslationVectorSize() const;
|
||||
bool getWideTranslation(const string& stringIn, wstring& wideOut) const;
|
||||
string& translate(const string& stringIn) const;
|
||||
|
||||
protected:
|
||||
void addPair(const string& english, const wstring& translated);
|
||||
// variables
|
||||
vector<pair<string, wstring> > m_translationVector;
|
||||
|
||||
private:
|
||||
// the number of translation pairs added a constructor
|
||||
static const size_t translationElements = 30; // need static for vs2013
|
||||
// the translated string
|
||||
mutable string m_mbTranslation;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Translation classes
|
||||
// One class for each language.
|
||||
// These classes have only a constructor which builds the language vector.
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class Bulgarian : public Translation
|
||||
{ public: Bulgarian(); };
|
||||
|
||||
class ChineseSimplified : public Translation
|
||||
{ public: ChineseSimplified(); };
|
||||
|
||||
class ChineseTraditional : public Translation
|
||||
{ public: ChineseTraditional(); };
|
||||
|
||||
class Dutch : public Translation
|
||||
{ public: Dutch(); };
|
||||
|
||||
class English : public Translation
|
||||
{ public: English(); };
|
||||
|
||||
class Estonian : public Translation
|
||||
{ public: Estonian(); };
|
||||
|
||||
class Finnish : public Translation
|
||||
{ public: Finnish(); };
|
||||
|
||||
class French : public Translation
|
||||
{ public: French(); };
|
||||
|
||||
class German : public Translation
|
||||
{ public: German(); };
|
||||
|
||||
class Greek : public Translation
|
||||
{ public: Greek(); };
|
||||
|
||||
class Hindi : public Translation
|
||||
{ public: Hindi(); };
|
||||
|
||||
class Hungarian : public Translation
|
||||
{ public: Hungarian(); };
|
||||
|
||||
class Italian : public Translation
|
||||
{ public: Italian(); };
|
||||
|
||||
class Japanese : public Translation
|
||||
{ public: Japanese(); };
|
||||
|
||||
class Korean : public Translation
|
||||
{ public: Korean(); };
|
||||
|
||||
class Norwegian : public Translation
|
||||
{ public: Norwegian(); };
|
||||
|
||||
class Polish : public Translation
|
||||
{ public: Polish(); };
|
||||
|
||||
class Portuguese : public Translation
|
||||
{ public: Portuguese(); };
|
||||
|
||||
class Romanian : public Translation
|
||||
{ public: Romanian(); };
|
||||
|
||||
class Russian : public Translation
|
||||
{ public: Russian(); };
|
||||
|
||||
class Spanish : public Translation
|
||||
{ public: Spanish(); };
|
||||
|
||||
class Swedish : public Translation
|
||||
{ public: Swedish(); };
|
||||
|
||||
class Ukrainian : public Translation
|
||||
{ public: Ukrainian(); };
|
||||
|
||||
|
||||
#endif // ASTYLE_LIB
|
||||
|
||||
} // namespace astyle
|
||||
|
||||
#endif // ASLOCALIZER_H
|
||||
|
|
@ -0,0 +1,785 @@
|
|||
// ASResource.cpp
|
||||
// Copyright (c) 2018 by Jim Pattee <jimp03@email.com>.
|
||||
// This code is licensed under the MIT License.
|
||||
// License.md describes the conditions under which this software may be distributed.
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// headers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "astyle.h"
|
||||
#include <algorithm>
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// astyle namespace
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace astyle {
|
||||
//
|
||||
const string ASResource::_AS_EXCEPT = string("__except");
|
||||
const string ASResource::_AS_FINALLY = string("__finally");
|
||||
const string ASResource::_AS_TRY = string("__try");
|
||||
const string ASResource::AS_ADD = string("add");
|
||||
const string ASResource::AS_AUTO = string("auto");
|
||||
const string ASResource::AS_AUTORELEASEPOOL = string("autoreleasepool");
|
||||
const string ASResource::AS_CASE = string("case");
|
||||
const string ASResource::AS_CATCH = string("catch");
|
||||
const string ASResource::AS_CLASS = string("class");
|
||||
const string ASResource::AS_CONST = string("const");
|
||||
const string ASResource::AS_CONST_CAST = string("const_cast");
|
||||
const string ASResource::AS_DEFAULT = string("default");
|
||||
const string ASResource::AS_DELEGATE = string("delegate");
|
||||
const string ASResource::AS_DELETE = string("delete");
|
||||
const string ASResource::AS_DO = string("do");
|
||||
const string ASResource::AS_DYNAMIC_CAST = string("dynamic_cast");
|
||||
const string ASResource::AS_ELSE = string("else");
|
||||
const string ASResource::AS_END = string("end");
|
||||
const string ASResource::AS_ENUM = string("enum");
|
||||
const string ASResource::AS_EXTERN = string("extern");
|
||||
const string ASResource::AS_FINAL = string("final");
|
||||
const string ASResource::AS_FINALLY = string("finally");
|
||||
const string ASResource::AS_FIXED = string("fixed");
|
||||
const string ASResource::AS_FOR = string("for");
|
||||
const string ASResource::AS_FOREACH = string("foreach");
|
||||
const string ASResource::AS_FOREVER = string("forever");
|
||||
const string ASResource::AS_GET = string("get");
|
||||
const string ASResource::AS_IF = string("if");
|
||||
const string ASResource::AS_INTERFACE = string("interface");
|
||||
const string ASResource::AS_INTERRUPT = string("interrupt");
|
||||
const string ASResource::AS_LET = string("let");
|
||||
const string ASResource::AS_LOCK = string("lock");
|
||||
const string ASResource::AS_MODULE = string("module"); // CORBA IDL module definition
|
||||
const string ASResource::AS_NAMESPACE = string("namespace");
|
||||
const string ASResource::AS_NEW = string("new");
|
||||
const string ASResource::AS_NOEXCEPT = string("noexcept");
|
||||
const string ASResource::AS_NS_DURING = string("NS_DURING");
|
||||
const string ASResource::AS_NS_HANDLER = string("NS_HANDLER");
|
||||
const string ASResource::AS_OPERATOR = string("operator");
|
||||
const string ASResource::AS_OVERRIDE = string("override");
|
||||
const string ASResource::AS_PRIVATE = string("private");
|
||||
const string ASResource::AS_PROTECTED = string("protected");
|
||||
const string ASResource::AS_PUBLIC = string("public");
|
||||
const string ASResource::AS_QFOREACH = string("Q_FOREACH");
|
||||
const string ASResource::AS_QFOREVER = string("Q_FOREVER");
|
||||
const string ASResource::AS_REINTERPRET_CAST = string("reinterpret_cast");
|
||||
const string ASResource::AS_REMOVE = string("remove");
|
||||
const string ASResource::AS_SEALED = string("sealed");
|
||||
const string ASResource::AS_SELECTOR = string("selector");
|
||||
const string ASResource::AS_SET = string("set");
|
||||
const string ASResource::AS_STATIC = string("static");
|
||||
const string ASResource::AS_STATIC_CAST = string("static_cast");
|
||||
const string ASResource::AS_STRUCT = string("struct");
|
||||
const string ASResource::AS_SWITCH = string("switch");
|
||||
const string ASResource::AS_SYNCHRONIZED = string("synchronized");
|
||||
const string ASResource::AS_TEMPLATE = string("template");
|
||||
const string ASResource::AS_THROW = string("throw");
|
||||
const string ASResource::AS_THROWS = string("throws");
|
||||
const string ASResource::AS_TRY = string("try");
|
||||
const string ASResource::AS_UNCHECKED = string("unchecked");
|
||||
const string ASResource::AS_UNION = string("union");
|
||||
const string ASResource::AS_UNSAFE = string("unsafe");
|
||||
const string ASResource::AS_USING = string("using");
|
||||
const string ASResource::AS_VOLATILE = string("volatile");
|
||||
const string ASResource::AS_WHERE = string("where");
|
||||
const string ASResource::AS_WHILE = string("while");
|
||||
|
||||
const string ASResource::AS_ASM = string("asm");
|
||||
const string ASResource::AS__ASM__ = string("__asm__");
|
||||
const string ASResource::AS_MS_ASM = string("_asm");
|
||||
const string ASResource::AS_MS__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_BRACE = string("{");
|
||||
const string ASResource::AS_CLOSE_BRACE = 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_GCC_MIN_ASSIGN = string("<?");
|
||||
const string ASResource::AS_GCC_MAX_ASSIGN = string(">?");
|
||||
|
||||
const string ASResource::AS_RETURN = string("return");
|
||||
const string ASResource::AS_CIN = string("cin");
|
||||
const string ASResource::AS_COUT = string("cout");
|
||||
const string ASResource::AS_CERR = string("cerr");
|
||||
|
||||
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_QUESTION_QUESTION = string("??");
|
||||
const string ASResource::AS_LAMBDA = string("=>"); // C# lambda expression arrow
|
||||
const string ASResource::AS_ARROW = string("->");
|
||||
const string ASResource::AS_AND = string("&&");
|
||||
const string ASResource::AS_OR = string("||");
|
||||
const string ASResource::AS_SCOPE_RESOLUTION = 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(";");
|
||||
|
||||
/**
|
||||
* Sort comparison function.
|
||||
* Compares the length of the value of pointers in the vectors.
|
||||
* The LONGEST strings will be first in the vector.
|
||||
*
|
||||
* @param a and b, the string pointers to be compared.
|
||||
*/
|
||||
bool sortOnLength(const string* a, const string* b)
|
||||
{
|
||||
return (*a).length() > (*b).length();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sort comparison function.
|
||||
* Compares the value of pointers in the vectors.
|
||||
*
|
||||
* @param a and b, the string pointers to be compared.
|
||||
*/
|
||||
bool sortOnName(const string* a, const string* b)
|
||||
{
|
||||
return *a < *b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of assignment operators.
|
||||
* Used by BOTH ASFormatter.cpp and ASBeautifier.cpp
|
||||
*
|
||||
* @param assignmentOperators a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildAssignmentOperators(vector<const string*>* assignmentOperators)
|
||||
{
|
||||
const size_t elements = 15;
|
||||
assignmentOperators->reserve(elements);
|
||||
|
||||
assignmentOperators->emplace_back(&AS_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_PLUS_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_MINUS_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_MULT_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_DIV_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_MOD_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_OR_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_AND_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_XOR_ASSIGN);
|
||||
|
||||
// Java
|
||||
assignmentOperators->emplace_back(&AS_GR_GR_GR_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_GR_GR_ASSIGN);
|
||||
assignmentOperators->emplace_back(&AS_LS_LS_ASSIGN);
|
||||
|
||||
// Unknown
|
||||
assignmentOperators->emplace_back(&AS_LS_LS_LS_ASSIGN);
|
||||
|
||||
assert(assignmentOperators->size() < elements);
|
||||
sort(assignmentOperators->begin(), assignmentOperators->end(), sortOnLength);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of C++ cast operators.
|
||||
* Used by ONLY ASFormatter.cpp
|
||||
*
|
||||
* @param castOperators a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildCastOperators(vector<const string*>* castOperators)
|
||||
{
|
||||
const size_t elements = 5;
|
||||
castOperators->reserve(elements);
|
||||
|
||||
castOperators->emplace_back(&AS_CONST_CAST);
|
||||
castOperators->emplace_back(&AS_DYNAMIC_CAST);
|
||||
castOperators->emplace_back(&AS_REINTERPRET_CAST);
|
||||
castOperators->emplace_back(&AS_STATIC_CAST);
|
||||
|
||||
assert(castOperators->size() < elements);
|
||||
sort(castOperators->begin(), castOperators->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of header words.
|
||||
* Used by BOTH ASFormatter.cpp and ASBeautifier.cpp
|
||||
*
|
||||
* @param headers a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildHeaders(vector<const string*>* headers, int fileType, bool beautifier)
|
||||
{
|
||||
const size_t elements = 25;
|
||||
headers->reserve(elements);
|
||||
|
||||
headers->emplace_back(&AS_IF);
|
||||
headers->emplace_back(&AS_ELSE);
|
||||
headers->emplace_back(&AS_FOR);
|
||||
headers->emplace_back(&AS_WHILE);
|
||||
headers->emplace_back(&AS_DO);
|
||||
headers->emplace_back(&AS_SWITCH);
|
||||
headers->emplace_back(&AS_CASE);
|
||||
headers->emplace_back(&AS_DEFAULT);
|
||||
headers->emplace_back(&AS_TRY);
|
||||
headers->emplace_back(&AS_CATCH);
|
||||
headers->emplace_back(&AS_QFOREACH); // QT
|
||||
headers->emplace_back(&AS_QFOREVER); // QT
|
||||
headers->emplace_back(&AS_FOREACH); // QT & C#
|
||||
headers->emplace_back(&AS_FOREVER); // Qt & Boost
|
||||
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
headers->emplace_back(&_AS_TRY); // __try
|
||||
headers->emplace_back(&_AS_FINALLY); // __finally
|
||||
headers->emplace_back(&_AS_EXCEPT); // __except
|
||||
}
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
headers->emplace_back(&AS_FINALLY);
|
||||
headers->emplace_back(&AS_SYNCHRONIZED);
|
||||
}
|
||||
|
||||
if (fileType == SHARP_TYPE)
|
||||
{
|
||||
headers->emplace_back(&AS_FINALLY);
|
||||
headers->emplace_back(&AS_LOCK);
|
||||
headers->emplace_back(&AS_FIXED);
|
||||
headers->emplace_back(&AS_GET);
|
||||
headers->emplace_back(&AS_SET);
|
||||
headers->emplace_back(&AS_ADD);
|
||||
headers->emplace_back(&AS_REMOVE);
|
||||
headers->emplace_back(&AS_USING);
|
||||
}
|
||||
|
||||
if (beautifier)
|
||||
{
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
headers->emplace_back(&AS_TEMPLATE);
|
||||
}
|
||||
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
headers->emplace_back(&AS_STATIC); // for static constructor
|
||||
}
|
||||
}
|
||||
|
||||
assert(headers->size() < elements);
|
||||
sort(headers->begin(), headers->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of indentable headers.
|
||||
* Used by ONLY ASBeautifier.cpp
|
||||
*
|
||||
* @param indentableHeaders a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildIndentableHeaders(vector<const string*>* indentableHeaders)
|
||||
{
|
||||
indentableHeaders->emplace_back(&AS_RETURN);
|
||||
|
||||
// sort(indentableHeaders->begin(), indentableHeaders->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of indentable macros pairs.
|
||||
* Initialized by ASFormatter, used by ONLY ASEnhancer.cpp
|
||||
*
|
||||
* @param indentableMacros a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildIndentableMacros(vector<const pair<const string, const string>* >* indentableMacros)
|
||||
{
|
||||
const size_t elements = 10;
|
||||
indentableMacros->reserve(elements);
|
||||
|
||||
// the pairs must be retained in memory because of pair pointers
|
||||
using macro_pair = pair<const string, const string>;
|
||||
static const macro_pair macros[] =
|
||||
{
|
||||
// wxWidgets
|
||||
macro_pair("BEGIN_EVENT_TABLE", "END_EVENT_TABLE"),
|
||||
macro_pair("wxBEGIN_EVENT_TABLE", "wxEND_EVENT_TABLE"),
|
||||
// MFC
|
||||
macro_pair("BEGIN_DISPATCH_MAP", "END_DISPATCH_MAP"),
|
||||
macro_pair("BEGIN_EVENT_MAP", "END_EVENT_MAP"),
|
||||
macro_pair("BEGIN_MESSAGE_MAP", "END_MESSAGE_MAP"),
|
||||
macro_pair("BEGIN_PROPPAGEIDS", "END_PROPPAGEIDS"),
|
||||
};
|
||||
|
||||
for (const macro_pair& macro : macros)
|
||||
indentableMacros->emplace_back(¯o);
|
||||
|
||||
assert(indentableMacros->size() < elements);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of non-assignment operators.
|
||||
* Used by ONLY ASBeautifier.cpp
|
||||
*
|
||||
* @param nonAssignmentOperators a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildNonAssignmentOperators(vector<const string*>* nonAssignmentOperators)
|
||||
{
|
||||
const size_t elements = 15;
|
||||
nonAssignmentOperators->reserve(elements);
|
||||
|
||||
nonAssignmentOperators->emplace_back(&AS_EQUAL);
|
||||
nonAssignmentOperators->emplace_back(&AS_PLUS_PLUS);
|
||||
nonAssignmentOperators->emplace_back(&AS_MINUS_MINUS);
|
||||
nonAssignmentOperators->emplace_back(&AS_NOT_EQUAL);
|
||||
nonAssignmentOperators->emplace_back(&AS_GR_EQUAL);
|
||||
nonAssignmentOperators->emplace_back(&AS_GR_GR_GR);
|
||||
nonAssignmentOperators->emplace_back(&AS_GR_GR);
|
||||
nonAssignmentOperators->emplace_back(&AS_LS_EQUAL);
|
||||
nonAssignmentOperators->emplace_back(&AS_LS_LS_LS);
|
||||
nonAssignmentOperators->emplace_back(&AS_LS_LS);
|
||||
nonAssignmentOperators->emplace_back(&AS_ARROW);
|
||||
nonAssignmentOperators->emplace_back(&AS_AND);
|
||||
nonAssignmentOperators->emplace_back(&AS_OR);
|
||||
nonAssignmentOperators->emplace_back(&AS_LAMBDA);
|
||||
|
||||
assert(nonAssignmentOperators->size() < elements);
|
||||
sort(nonAssignmentOperators->begin(), nonAssignmentOperators->end(), sortOnLength);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of header non-paren headers.
|
||||
* Used by BOTH ASFormatter.cpp and ASBeautifier.cpp.
|
||||
* NOTE: Non-paren headers should also be included in the headers vector.
|
||||
*
|
||||
* @param nonParenHeaders a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildNonParenHeaders(vector<const string*>* nonParenHeaders, int fileType, bool beautifier)
|
||||
{
|
||||
const size_t elements = 20;
|
||||
nonParenHeaders->reserve(elements);
|
||||
|
||||
nonParenHeaders->emplace_back(&AS_ELSE);
|
||||
nonParenHeaders->emplace_back(&AS_DO);
|
||||
nonParenHeaders->emplace_back(&AS_TRY);
|
||||
nonParenHeaders->emplace_back(&AS_CATCH); // can be paren or non-paren
|
||||
nonParenHeaders->emplace_back(&AS_CASE); // can be paren or non-paren
|
||||
nonParenHeaders->emplace_back(&AS_DEFAULT);
|
||||
nonParenHeaders->emplace_back(&AS_QFOREVER); // QT
|
||||
nonParenHeaders->emplace_back(&AS_FOREVER); // Boost
|
||||
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
nonParenHeaders->emplace_back(&_AS_TRY); // __try
|
||||
nonParenHeaders->emplace_back(&_AS_FINALLY); // __finally
|
||||
}
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
nonParenHeaders->emplace_back(&AS_FINALLY);
|
||||
}
|
||||
|
||||
if (fileType == SHARP_TYPE)
|
||||
{
|
||||
nonParenHeaders->emplace_back(&AS_FINALLY);
|
||||
nonParenHeaders->emplace_back(&AS_GET);
|
||||
nonParenHeaders->emplace_back(&AS_SET);
|
||||
nonParenHeaders->emplace_back(&AS_ADD);
|
||||
nonParenHeaders->emplace_back(&AS_REMOVE);
|
||||
}
|
||||
|
||||
if (beautifier)
|
||||
{
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
nonParenHeaders->emplace_back(&AS_TEMPLATE);
|
||||
}
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
nonParenHeaders->emplace_back(&AS_STATIC);
|
||||
}
|
||||
}
|
||||
|
||||
assert(nonParenHeaders->size() < elements);
|
||||
sort(nonParenHeaders->begin(), nonParenHeaders->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of operators.
|
||||
* Used by ONLY ASFormatter.cpp
|
||||
*
|
||||
* @param operators a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildOperators(vector<const string*>* operators, int fileType)
|
||||
{
|
||||
const size_t elements = 50;
|
||||
operators->reserve(elements);
|
||||
|
||||
operators->emplace_back(&AS_PLUS_ASSIGN);
|
||||
operators->emplace_back(&AS_MINUS_ASSIGN);
|
||||
operators->emplace_back(&AS_MULT_ASSIGN);
|
||||
operators->emplace_back(&AS_DIV_ASSIGN);
|
||||
operators->emplace_back(&AS_MOD_ASSIGN);
|
||||
operators->emplace_back(&AS_OR_ASSIGN);
|
||||
operators->emplace_back(&AS_AND_ASSIGN);
|
||||
operators->emplace_back(&AS_XOR_ASSIGN);
|
||||
operators->emplace_back(&AS_EQUAL);
|
||||
operators->emplace_back(&AS_PLUS_PLUS);
|
||||
operators->emplace_back(&AS_MINUS_MINUS);
|
||||
operators->emplace_back(&AS_NOT_EQUAL);
|
||||
operators->emplace_back(&AS_GR_EQUAL);
|
||||
operators->emplace_back(&AS_GR_GR_GR_ASSIGN);
|
||||
operators->emplace_back(&AS_GR_GR_ASSIGN);
|
||||
operators->emplace_back(&AS_GR_GR_GR);
|
||||
operators->emplace_back(&AS_GR_GR);
|
||||
operators->emplace_back(&AS_LS_EQUAL);
|
||||
operators->emplace_back(&AS_LS_LS_LS_ASSIGN);
|
||||
operators->emplace_back(&AS_LS_LS_ASSIGN);
|
||||
operators->emplace_back(&AS_LS_LS_LS);
|
||||
operators->emplace_back(&AS_LS_LS);
|
||||
operators->emplace_back(&AS_QUESTION_QUESTION);
|
||||
operators->emplace_back(&AS_LAMBDA);
|
||||
operators->emplace_back(&AS_ARROW);
|
||||
operators->emplace_back(&AS_AND);
|
||||
operators->emplace_back(&AS_OR);
|
||||
operators->emplace_back(&AS_SCOPE_RESOLUTION);
|
||||
operators->emplace_back(&AS_PLUS);
|
||||
operators->emplace_back(&AS_MINUS);
|
||||
operators->emplace_back(&AS_MULT);
|
||||
operators->emplace_back(&AS_DIV);
|
||||
operators->emplace_back(&AS_MOD);
|
||||
operators->emplace_back(&AS_QUESTION);
|
||||
operators->emplace_back(&AS_COLON);
|
||||
operators->emplace_back(&AS_ASSIGN);
|
||||
operators->emplace_back(&AS_LS);
|
||||
operators->emplace_back(&AS_GR);
|
||||
operators->emplace_back(&AS_NOT);
|
||||
operators->emplace_back(&AS_BIT_OR);
|
||||
operators->emplace_back(&AS_BIT_AND);
|
||||
operators->emplace_back(&AS_BIT_NOT);
|
||||
operators->emplace_back(&AS_BIT_XOR);
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
operators->emplace_back(&AS_GCC_MIN_ASSIGN);
|
||||
operators->emplace_back(&AS_GCC_MAX_ASSIGN);
|
||||
}
|
||||
|
||||
assert(operators->size() < elements);
|
||||
sort(operators->begin(), operators->end(), sortOnLength);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of pre-block statements.
|
||||
* Used by ONLY ASBeautifier.cpp
|
||||
* NOTE: Cannot be both a header and a preBlockStatement.
|
||||
*
|
||||
* @param preBlockStatements a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildPreBlockStatements(vector<const string*>* preBlockStatements, int fileType)
|
||||
{
|
||||
const size_t elements = 10;
|
||||
preBlockStatements->reserve(elements);
|
||||
|
||||
preBlockStatements->emplace_back(&AS_CLASS);
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
preBlockStatements->emplace_back(&AS_STRUCT);
|
||||
preBlockStatements->emplace_back(&AS_UNION);
|
||||
preBlockStatements->emplace_back(&AS_NAMESPACE);
|
||||
preBlockStatements->emplace_back(&AS_MODULE); // for CORBA IDL
|
||||
preBlockStatements->emplace_back(&AS_INTERFACE); // for CORBA IDL
|
||||
}
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
preBlockStatements->emplace_back(&AS_INTERFACE);
|
||||
preBlockStatements->emplace_back(&AS_THROWS);
|
||||
}
|
||||
if (fileType == SHARP_TYPE)
|
||||
{
|
||||
preBlockStatements->emplace_back(&AS_INTERFACE);
|
||||
preBlockStatements->emplace_back(&AS_NAMESPACE);
|
||||
preBlockStatements->emplace_back(&AS_WHERE);
|
||||
preBlockStatements->emplace_back(&AS_STRUCT);
|
||||
}
|
||||
|
||||
assert(preBlockStatements->size() < elements);
|
||||
sort(preBlockStatements->begin(), preBlockStatements->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of pre-command headers.
|
||||
* Used by BOTH ASFormatter.cpp and ASBeautifier.cpp.
|
||||
* NOTE: Cannot be both a header and a preCommandHeader.
|
||||
*
|
||||
* A preCommandHeader is in a function definition between
|
||||
* the closing paren and the opening brace.
|
||||
* e.g. in "void foo() const {}", "const" is a preCommandHeader.
|
||||
*/
|
||||
void ASResource::buildPreCommandHeaders(vector<const string*>* preCommandHeaders, int fileType)
|
||||
{
|
||||
const size_t elements = 10;
|
||||
preCommandHeaders->reserve(elements);
|
||||
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
preCommandHeaders->emplace_back(&AS_CONST);
|
||||
preCommandHeaders->emplace_back(&AS_FINAL);
|
||||
preCommandHeaders->emplace_back(&AS_INTERRUPT);
|
||||
preCommandHeaders->emplace_back(&AS_NOEXCEPT);
|
||||
preCommandHeaders->emplace_back(&AS_OVERRIDE);
|
||||
preCommandHeaders->emplace_back(&AS_VOLATILE);
|
||||
preCommandHeaders->emplace_back(&AS_SEALED); // Visual C only
|
||||
preCommandHeaders->emplace_back(&AS_AUTORELEASEPOOL); // Obj-C only
|
||||
}
|
||||
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
preCommandHeaders->emplace_back(&AS_THROWS);
|
||||
}
|
||||
|
||||
if (fileType == SHARP_TYPE)
|
||||
{
|
||||
preCommandHeaders->emplace_back(&AS_WHERE);
|
||||
}
|
||||
|
||||
assert(preCommandHeaders->size() < elements);
|
||||
sort(preCommandHeaders->begin(), preCommandHeaders->end(), sortOnName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the vector of pre-definition headers.
|
||||
* Used by ONLY ASFormatter.cpp
|
||||
* NOTE: Do NOT add 'enum' here. It is an array type brace.
|
||||
* NOTE: Do NOT add 'extern' here. Do not want an extra indent.
|
||||
*
|
||||
* @param preDefinitionHeaders a reference to the vector to be built.
|
||||
*/
|
||||
void ASResource::buildPreDefinitionHeaders(vector<const string*>* preDefinitionHeaders, int fileType)
|
||||
{
|
||||
const size_t elements = 10;
|
||||
preDefinitionHeaders->reserve(elements);
|
||||
|
||||
preDefinitionHeaders->emplace_back(&AS_CLASS);
|
||||
if (fileType == C_TYPE)
|
||||
{
|
||||
preDefinitionHeaders->emplace_back(&AS_STRUCT);
|
||||
preDefinitionHeaders->emplace_back(&AS_UNION);
|
||||
preDefinitionHeaders->emplace_back(&AS_NAMESPACE);
|
||||
preDefinitionHeaders->emplace_back(&AS_MODULE); // for CORBA IDL
|
||||
preDefinitionHeaders->emplace_back(&AS_INTERFACE); // for CORBA IDL
|
||||
}
|
||||
if (fileType == JAVA_TYPE)
|
||||
{
|
||||
preDefinitionHeaders->emplace_back(&AS_INTERFACE);
|
||||
}
|
||||
if (fileType == SHARP_TYPE)
|
||||
{
|
||||
preDefinitionHeaders->emplace_back(&AS_STRUCT);
|
||||
preDefinitionHeaders->emplace_back(&AS_INTERFACE);
|
||||
preDefinitionHeaders->emplace_back(&AS_NAMESPACE);
|
||||
}
|
||||
|
||||
assert(preDefinitionHeaders->size() < elements);
|
||||
sort(preDefinitionHeaders->begin(), preDefinitionHeaders->end(), sortOnName);
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||||
* ASBase Functions
|
||||
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||||
|
||||
// check if a specific line position contains a header.
|
||||
const string* ASBase::findHeader(const string& line, int i,
|
||||
const vector<const string*>* possibleHeaders) const
|
||||
{
|
||||
assert(isCharPotentialHeader(line, i));
|
||||
// check the word
|
||||
size_t maxHeaders = possibleHeaders->size();
|
||||
for (size_t p = 0; p < maxHeaders; p++)
|
||||
{
|
||||
const string* header = (*possibleHeaders)[p];
|
||||
const size_t wordEnd = i + header->length();
|
||||
if (wordEnd > line.length())
|
||||
continue;
|
||||
int result = (line.compare(i, header->length(), *header));
|
||||
if (result > 0)
|
||||
continue;
|
||||
if (result < 0)
|
||||
break;
|
||||
// check that this is not part of a longer word
|
||||
if (wordEnd == line.length())
|
||||
return header;
|
||||
if (isLegalNameChar(line[wordEnd]))
|
||||
continue;
|
||||
const char peekChar = peekNextChar(line, wordEnd - 1);
|
||||
// is not a header if part of a definition
|
||||
if (peekChar == ',' || peekChar == ')')
|
||||
break;
|
||||
// the following accessor definitions are NOT headers
|
||||
// goto default; is NOT a header
|
||||
// default(int) keyword in C# is NOT a header
|
||||
if ((header == &AS_GET
|
||||
|| header == &AS_SET
|
||||
|| header == &AS_DEFAULT)
|
||||
&& (peekChar == ';' || peekChar == '(' || peekChar == '='))
|
||||
break;
|
||||
return header;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// check if a specific line position contains a keyword.
|
||||
bool ASBase::findKeyword(const string& line, int i, const string& keyword) const
|
||||
{
|
||||
assert(isCharPotentialHeader(line, i));
|
||||
// check the word
|
||||
const size_t keywordLength = keyword.length();
|
||||
const size_t wordEnd = i + keywordLength;
|
||||
if (wordEnd > line.length())
|
||||
return false;
|
||||
if (line.compare(i, keywordLength, keyword) != 0)
|
||||
return false;
|
||||
// check that this is not part of a longer word
|
||||
if (wordEnd == line.length())
|
||||
return true;
|
||||
if (isLegalNameChar(line[wordEnd]))
|
||||
return false;
|
||||
// is not a keyword if part of a definition
|
||||
const char peekChar = peekNextChar(line, (int) wordEnd - 1);
|
||||
if (peekChar == ',' || peekChar == ')')
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
// check if a specific line position contains an operator.
|
||||
const string* ASBase::findOperator(const string& line, int i,
|
||||
const vector<const string*>* possibleOperators) const
|
||||
{
|
||||
assert(isCharPotentialOperator(line[i]));
|
||||
// find the operator in the vector
|
||||
// the vector contains the LONGEST operators first
|
||||
// must loop thru the entire vector
|
||||
size_t maxOperators = possibleOperators->size();
|
||||
for (size_t p = 0; p < maxOperators; p++)
|
||||
{
|
||||
const size_t wordEnd = i + (*(*possibleOperators)[p]).length();
|
||||
if (wordEnd > line.length())
|
||||
continue;
|
||||
if (line.compare(i, (*(*possibleOperators)[p]).length(), *(*possibleOperators)[p]) == 0)
|
||||
return (*possibleOperators)[p];
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// get the current word on a line
|
||||
// index must point to the beginning of the word
|
||||
string ASBase::getCurrentWord(const string& line, size_t index) const
|
||||
{
|
||||
assert(isCharPotentialHeader(line, index));
|
||||
size_t lineLength = line.length();
|
||||
size_t i;
|
||||
for (i = index; i < lineLength; i++)
|
||||
{
|
||||
if (!isLegalNameChar(line[i]))
|
||||
break;
|
||||
}
|
||||
return line.substr(index, i - index);
|
||||
}
|
||||
|
||||
// check if a specific character can be used in a legal variable/method/class name
|
||||
bool ASBase::isLegalNameChar(char ch) const
|
||||
{
|
||||
if (isWhiteSpace(ch))
|
||||
return false;
|
||||
if ((unsigned char) ch > 127)
|
||||
return false;
|
||||
return (isalnum((unsigned char) ch)
|
||||
|| ch == '.' || ch == '_'
|
||||
|| (isJavaStyle() && ch == '$')
|
||||
|| (isSharpStyle() && ch == '@')); // may be used as a prefix
|
||||
}
|
||||
|
||||
// check if a specific character can be part of a header
|
||||
bool ASBase::isCharPotentialHeader(const string& line, size_t i) const
|
||||
{
|
||||
assert(!isWhiteSpace(line[i]));
|
||||
char prevCh = ' ';
|
||||
if (i > 0)
|
||||
prevCh = line[i - 1];
|
||||
if (i > 1 && line[i - 2] == '\\')
|
||||
prevCh = ' ';
|
||||
if (!isLegalNameChar(prevCh) && isLegalNameChar(line[i]))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// check if a specific character can be part of an operator
|
||||
bool ASBase::isCharPotentialOperator(char ch) const
|
||||
{
|
||||
assert(!isWhiteSpace(ch));
|
||||
if ((unsigned) ch > 127)
|
||||
return false;
|
||||
return (ispunct((unsigned char) ch)
|
||||
&& ch != '{' && ch != '}'
|
||||
&& ch != '(' && ch != ')'
|
||||
&& ch != '[' && ch != ']'
|
||||
&& ch != ';' && ch != ','
|
||||
&& ch != '#' && ch != '\\'
|
||||
&& ch != '\'' && ch != '\"');
|
||||
}
|
||||
|
||||
// check if a specific character is a digit
|
||||
// NOTE: Visual C isdigit() gives assert error if char > 256
|
||||
bool ASBase::isDigit(char ch) const
|
||||
{
|
||||
return (ch >= '0' && ch <= '9');
|
||||
}
|
||||
|
||||
// check if a specific character is a digit separator
|
||||
bool ASBase::isDigitSeparator(const string& line, int i) const
|
||||
{
|
||||
assert(line[i] == '\'');
|
||||
// casting to (unsigned char) eliminates negative characters
|
||||
// will get a "Debug Assertion Failed" if not cast
|
||||
bool foundDigitSeparator = i > 0
|
||||
&& isxdigit((unsigned char) line[i - 1])
|
||||
&& i < (int) line.length() - 1
|
||||
&& isxdigit((unsigned char) line[i + 1]);
|
||||
return foundDigitSeparator;
|
||||
}
|
||||
|
||||
// peek at the next unread character.
|
||||
char ASBase::peekNextChar(const string& line, int i) const
|
||||
{
|
||||
char ch = ' ';
|
||||
size_t peekNum = line.find_first_not_of(" \t", i + 1);
|
||||
if (peekNum == string::npos)
|
||||
return ch;
|
||||
ch = line[peekNum];
|
||||
return ch;
|
||||
}
|
||||
|
||||
} // end namespace astyle
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,28 @@
|
|||
QT -= gui
|
||||
|
||||
APP_NAME = RedPandaIDE
|
||||
|
||||
CONFIG += c++11 console
|
||||
CONFIG -= app_bundle
|
||||
|
||||
# You can make your code fail to compile if it uses deprecated APIs.
|
||||
# In order to do so, uncomment the following line.
|
||||
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
|
||||
|
||||
SOURCES += \
|
||||
ASBeautifier.cpp \
|
||||
ASEnhancer.cpp \
|
||||
ASFormatter.cpp \
|
||||
ASLocalizer.cpp \
|
||||
ASResource.cpp \
|
||||
astyle_main.cpp
|
||||
|
||||
# Default rules for deployment.
|
||||
qnx: target.path = /tmp/$${APP_NAME}/bin
|
||||
else: unix:!android: target.path = /opt/$${APP_NAME}/bin
|
||||
!isEmpty(target.path): INSTALLS += target
|
||||
|
||||
HEADERS += \
|
||||
ASLocalizer.h \
|
||||
astyle.h \
|
||||
astyle_main.h
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,429 @@
|
|||
// astyle_main.h
|
||||
// Copyright (c) 2018 by Jim Pattee <jimp03@email.com>.
|
||||
// This code is licensed under the MIT License.
|
||||
// License.md describes the conditions under which this software may be distributed.
|
||||
|
||||
#ifndef ASTYLE_MAIN_H
|
||||
#define ASTYLE_MAIN_H
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// headers
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#include "astyle.h"
|
||||
|
||||
#include <ctime>
|
||||
#include <sstream>
|
||||
|
||||
#if defined(__BORLANDC__) && __BORLANDC__ < 0x0650
|
||||
// Embarcadero needs this for the following utime.h
|
||||
// otherwise "struct utimbuf" gets an error on time_t
|
||||
// 0x0650 for C++Builder XE3
|
||||
using std::time_t;
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#include <sys/stat.h>
|
||||
#include <sys/utime.h>
|
||||
#else
|
||||
#include <sys/stat.h>
|
||||
#include <utime.h>
|
||||
#endif // end compiler checks
|
||||
|
||||
#ifdef ASTYLE_JNI
|
||||
#include <jni.h>
|
||||
#ifndef ASTYLE_LIB // ASTYLE_LIB must be defined for ASTYLE_JNI
|
||||
#define ASTYLE_LIB
|
||||
#endif
|
||||
#endif // ASTYLE_JNI
|
||||
|
||||
#ifndef ASTYLE_LIB
|
||||
// for console build only
|
||||
#include "ASLocalizer.h"
|
||||
#define _(a) localizer.settext(a)
|
||||
#endif // ASTYLE_LIB
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// declarations
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
// for getenv and localtime
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(disable: 4996) // secure version deprecation warnings
|
||||
#endif
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-declarations" // getenv, localtime
|
||||
#pragma clang diagnostic ignored "-Wmissing-braces"
|
||||
#endif
|
||||
|
||||
#ifdef ASTYLE_LIB
|
||||
// define STDCALL and EXPORT for Windows
|
||||
// MINGW defines STDCALL in Windows.h (actually windef.h)
|
||||
// EXPORT has no value if ASTYLE_NO_EXPORT is defined
|
||||
#ifdef _WIN32
|
||||
#ifndef STDCALL
|
||||
#define STDCALL __stdcall
|
||||
#endif
|
||||
// define this to prevent compiler warning and error messages
|
||||
#ifdef ASTYLE_NO_EXPORT
|
||||
#define EXPORT
|
||||
#else
|
||||
#define EXPORT __declspec(dllexport)
|
||||
#endif
|
||||
// define STDCALL and EXPORT for non-Windows
|
||||
// visibility attribute allows "-fvisibility=hidden" compiler option
|
||||
#else
|
||||
#define STDCALL
|
||||
#if __GNUC__ >= 4
|
||||
#define EXPORT __attribute__ ((visibility ("default")))
|
||||
#else
|
||||
#define EXPORT
|
||||
#endif
|
||||
#endif // #ifdef _WIN32
|
||||
// define pointers to callback error handler and memory allocation
|
||||
typedef void (STDCALL* fpError)(int errorNumber, const char* errorMessage);
|
||||
typedef char* (STDCALL* fpAlloc)(unsigned long memoryNeeded);
|
||||
#endif // #ifdef ASTYLE_LIB
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// astyle namespace
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
namespace astyle {
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
// ASStreamIterator class
|
||||
// typename will be stringstream for AStyle
|
||||
// it could be istream for plug-ins
|
||||
// ASSourceIterator is an inherited abstract class defined in astyle.h
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
template<typename T>
|
||||
class ASStreamIterator : public ASSourceIterator
|
||||
{
|
||||
public:
|
||||
bool checkForEmptyLine;
|
||||
|
||||
public: // function declarations
|
||||
explicit ASStreamIterator(T* in);
|
||||
~ASStreamIterator() override;
|
||||
bool getLineEndChange(int lineEndFormat) const;
|
||||
int getStreamLength() const override;
|
||||
string nextLine(bool emptyLineWasDeleted) override;
|
||||
string peekNextLine() override;
|
||||
void peekReset() override;
|
||||
void saveLastInputLine();
|
||||
streamoff tellg() override;
|
||||
|
||||
private:
|
||||
T* inStream; // pointer to the input stream
|
||||
string buffer; // current input line
|
||||
string prevBuffer; // previous input line
|
||||
string outputEOL; // next output end of line char
|
||||
int eolWindows; // number of Windows line endings, CRLF
|
||||
int eolLinux; // number of Linux line endings, LF
|
||||
int eolMacOld; // number of old Mac line endings. CR
|
||||
streamoff streamLength; // length of the input file stream
|
||||
streamoff peekStart; // starting position for peekNextLine
|
||||
bool prevLineDeleted; // the previous input line was deleted
|
||||
|
||||
public: // inline functions
|
||||
bool compareToInputBuffer(const string& nextLine_) const
|
||||
{ return (nextLine_ == prevBuffer); }
|
||||
const string& getOutputEOL() const { return outputEOL; }
|
||||
streamoff getPeekStart() const override { return peekStart; }
|
||||
bool hasMoreLines() const override { return !inStream->eof(); }
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// ASEncoding class for utf8/16 conversions
|
||||
// used by both console and library builds
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class ASEncoding
|
||||
{
|
||||
private:
|
||||
using utf16 = char16_t; // 16 bits unsigned
|
||||
using utf8 = unsigned char; // 8 bits
|
||||
using ubyte = unsigned char; // 8 bits
|
||||
enum { SURROGATE_LEAD_FIRST = 0xD800 };
|
||||
enum { SURROGATE_LEAD_LAST = 0xDBFF };
|
||||
enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
|
||||
enum { SURROGATE_TRAIL_LAST = 0xDFFF };
|
||||
enum { SURROGATE_FIRST_VALUE = 0x10000 };
|
||||
enum eState { eStart, eSecondOf4Bytes, ePenultimate, eFinal };
|
||||
|
||||
public:
|
||||
bool getBigEndian() const;
|
||||
int swap16bit(int value) const;
|
||||
size_t utf16len(const utf16* utf16In) const;
|
||||
size_t utf8LengthFromUtf16(const char* utf16In, size_t inLen, bool isBigEndian) const;
|
||||
size_t utf8ToUtf16(char* utf8In, size_t inLen, bool isBigEndian, char* utf16Out) const;
|
||||
size_t utf16LengthFromUtf8(const char* utf8In, size_t len) const;
|
||||
size_t utf16ToUtf8(char* utf16In, size_t inLen, bool isBigEndian,
|
||||
bool firstBlock, char* utf8Out) const;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// ASOptions class for options processing
|
||||
// used by both console and library builds
|
||||
//----------------------------------------------------------------------------
|
||||
class ASConsole;
|
||||
|
||||
class ASOptions
|
||||
{
|
||||
public:
|
||||
#ifdef ASTYLE_LIB
|
||||
ASOptions(ASFormatter& formatterArg);
|
||||
#else
|
||||
ASOptions(ASFormatter& formatterArg, ASConsole& consoleArg);
|
||||
#endif
|
||||
string getOptionErrors() const;
|
||||
void importOptions(stringstream& in, vector<string>& optionsVector);
|
||||
bool parseOptions(vector<string>& optionsVector, const string& errorInfo);
|
||||
|
||||
private:
|
||||
// variables
|
||||
ASFormatter& formatter;
|
||||
stringstream optionErrors; // option error messages
|
||||
#ifndef ASTYLE_LIB
|
||||
ASConsole& console; // DO NOT USE for ASTYLE_LIB
|
||||
#endif
|
||||
|
||||
// functions
|
||||
string getParam(const string& arg, const char* op);
|
||||
string getParam(const string& arg, const char* op1, const char* op2);
|
||||
bool isOption(const string& arg, const char* op);
|
||||
bool isOption(const string& arg, const char* op1, const char* op2);
|
||||
void isOptionError(const string& arg, const string& errorInfo);
|
||||
bool isParamOption(const string& arg, const char* option);
|
||||
bool isParamOption(const string& arg, const char* option1, const char* option2);
|
||||
void parseOption(const string& arg, const string& errorInfo);
|
||||
bool parseOptionContinued(const string& arg, const string& errorInfo);
|
||||
};
|
||||
|
||||
#ifndef ASTYLE_LIB
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// ASConsole class for console build
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class ASConsole
|
||||
{
|
||||
private: // variables
|
||||
ASFormatter& formatter; // reference to the ASFormatter object
|
||||
ASEncoding encode; // file encoding conversion
|
||||
ASLocalizer localizer; // language translation
|
||||
ostream* errorStream; // direct error messages to cerr or cout
|
||||
// command line options
|
||||
bool isRecursive; // recursive option
|
||||
bool isDryRun; // dry-run option
|
||||
bool noBackup; // suffix=none option
|
||||
bool preserveDate; // preserve-date option
|
||||
bool isVerbose; // verbose option
|
||||
bool isQuiet; // quiet option
|
||||
bool isFormattedOnly; // formatted lines only option
|
||||
bool ignoreExcludeErrors; // don't abort on unmatched excludes
|
||||
bool ignoreExcludeErrorsDisplay; // don't display unmatched excludes
|
||||
bool useAscii; // ascii option
|
||||
// other variables
|
||||
bool bypassBrowserOpen; // don't open the browser on html options
|
||||
bool hasWildcard; // file name includes a wildcard
|
||||
size_t mainDirectoryLength; // directory length to be excluded in displays
|
||||
bool filesAreIdentical; // input and output files are identical
|
||||
int filesFormatted; // number of files formatted
|
||||
int filesUnchanged; // number of files unchanged
|
||||
bool lineEndsMixed; // output has mixed line ends
|
||||
int linesOut; // number of output lines
|
||||
|
||||
string outputEOL; // current line end
|
||||
string prevEOL; // previous line end
|
||||
string astyleExePath; // absolute executable path and name from argv[0]
|
||||
string optionFileName; // file path and name of the options file
|
||||
string origSuffix; // suffix= option
|
||||
string projectOptionFileName; // file path and name of the project options file
|
||||
string stdPathIn; // path to input from stdin=
|
||||
string stdPathOut; // path to output from stdout=
|
||||
string targetDirectory; // path to the directory being processed
|
||||
string targetFilename; // file name being processed
|
||||
|
||||
vector<string> excludeVector; // exclude from wildcard hits
|
||||
vector<bool> excludeHitsVector; // exclude flags for error reporting
|
||||
vector<string> fileNameVector; // file paths and names from the command line
|
||||
vector<string> optionsVector; // options from the command line
|
||||
vector<string> projectOptionsVector;// project options from the project options file
|
||||
vector<string> fileOptionsVector; // options from the options file
|
||||
vector<string> fileName; // files to be processed including path
|
||||
|
||||
public: // functions
|
||||
explicit ASConsole(ASFormatter& formatterArg);
|
||||
ASConsole(const ASConsole&) = delete;
|
||||
ASConsole& operator=(ASConsole const&) = delete;
|
||||
void convertLineEnds(ostringstream& out, int lineEnd);
|
||||
FileEncoding detectEncoding(const char* data, size_t dataSize) const;
|
||||
void error() const;
|
||||
void error(const char* why, const char* what) const;
|
||||
void formatCinToCout();
|
||||
vector<string> getArgvOptions(int argc, char** argv);
|
||||
bool fileExists(const char* file) const;
|
||||
bool fileNameVectorIsEmpty() const;
|
||||
ostream* getErrorStream() const;
|
||||
bool getFilesAreIdentical() const;
|
||||
int getFilesFormatted() const;
|
||||
bool getIgnoreExcludeErrors() const;
|
||||
bool getIgnoreExcludeErrorsDisplay() const;
|
||||
bool getIsDryRun() const;
|
||||
bool getIsFormattedOnly() const;
|
||||
bool getIsQuiet() const;
|
||||
bool getIsRecursive() const;
|
||||
bool getIsVerbose() const;
|
||||
bool getLineEndsMixed() const;
|
||||
bool getNoBackup() const;
|
||||
bool getPreserveDate() const;
|
||||
string getLanguageID() const;
|
||||
string getNumberFormat(int num, size_t lcid = 0) const;
|
||||
string getNumberFormat(int num, const char* groupingArg, const char* separator) const;
|
||||
string getOptionFileName() const;
|
||||
string getOrigSuffix() const;
|
||||
string getProjectOptionFileName() const;
|
||||
string getStdPathIn() const;
|
||||
string getStdPathOut() const;
|
||||
void getTargetFilenames(string& targetFilename_, vector<string>& targetFilenameVector) const;
|
||||
void processFiles();
|
||||
void processOptions(const vector<string>& argvOptions);
|
||||
void setBypassBrowserOpen(bool state);
|
||||
void setErrorStream(ostream* errStreamPtr);
|
||||
void setIgnoreExcludeErrors(bool state);
|
||||
void setIgnoreExcludeErrorsAndDisplay(bool state);
|
||||
void setIsDryRun(bool state);
|
||||
void setIsFormattedOnly(bool state);
|
||||
void setIsQuiet(bool state);
|
||||
void setIsRecursive(bool state);
|
||||
void setIsVerbose(bool state);
|
||||
void setNoBackup(bool state);
|
||||
void setOptionFileName(const string& name);
|
||||
void setOrigSuffix(const string& suffix);
|
||||
void setPreserveDate(bool state);
|
||||
void setProjectOptionFileName(const string& optfilepath);
|
||||
void setStdPathIn(const string& path);
|
||||
void setStdPathOut(const string& path);
|
||||
void standardizePath(string& path, bool removeBeginningSeparator = false) const;
|
||||
bool stringEndsWith(const string& str, const string& suffix) const;
|
||||
void updateExcludeVector(const string& suffixParam);
|
||||
vector<string> getExcludeVector() const;
|
||||
vector<bool> getExcludeHitsVector() const;
|
||||
vector<string> getFileNameVector() const;
|
||||
vector<string> getOptionsVector() const;
|
||||
vector<string> getProjectOptionsVector() const;
|
||||
vector<string> getFileOptionsVector() const;
|
||||
vector<string> getFileName() const;
|
||||
|
||||
private: // functions
|
||||
void correctMixedLineEnds(ostringstream& out);
|
||||
void formatFile(const string& fileName_);
|
||||
string getParentDirectory(const string& absPath) const;
|
||||
string findProjectOptionFilePath(const string& fileName_) const;
|
||||
string getCurrentDirectory(const string& fileName_) const;
|
||||
void getFileNames(const string& directory, const vector<string>& wildcards);
|
||||
void getFilePaths(const string& filePath);
|
||||
string getFullPathName(const string& relativePath) const;
|
||||
string getHtmlInstallPrefix() const;
|
||||
string getParam(const string& arg, const char* op);
|
||||
bool isHomeOrInvalidAbsPath(const string& absPath) const;
|
||||
void initializeOutputEOL(LineEndFormat lineEndFormat);
|
||||
bool isOption(const string& arg, const char* op);
|
||||
bool isOption(const string& arg, const char* a, const char* b);
|
||||
bool isParamOption(const string& arg, const char* option);
|
||||
bool isPathExclued(const string& subPath);
|
||||
void launchDefaultBrowser(const char* filePathIn = nullptr) const;
|
||||
void printHelp() const;
|
||||
void printMsg(const char* msg, const string& data) const;
|
||||
void printSeparatingLine() const;
|
||||
void printVerboseHeader() const;
|
||||
void printVerboseStats(clock_t startTime) const;
|
||||
FileEncoding readFile(const string& fileName_, stringstream& in) const;
|
||||
void removeFile(const char* fileName_, const char* errMsg) const;
|
||||
void renameFile(const char* oldFileName, const char* newFileName, const char* errMsg) const;
|
||||
void setOutputEOL(LineEndFormat lineEndFormat, const string& currentEOL);
|
||||
void sleep(int seconds) const;
|
||||
int waitForRemove(const char* newFileName) const;
|
||||
int wildcmp(const char* wild, const char* data) const;
|
||||
void writeFile(const string& fileName_, FileEncoding encoding, ostringstream& out) const;
|
||||
#ifdef _WIN32
|
||||
void displayLastError();
|
||||
#endif
|
||||
};
|
||||
#else // ASTYLE_LIB
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// ASLibrary class for library build
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
class ASLibrary
|
||||
{
|
||||
public:
|
||||
ASLibrary() = default;
|
||||
virtual ~ASLibrary() = default;
|
||||
// virtual functions are mocked in testing
|
||||
char16_t* formatUtf16(const char16_t*, const char16_t*, fpError, fpAlloc) const;
|
||||
virtual char16_t* convertUtf8ToUtf16(const char* utf8In, fpAlloc fpMemoryAlloc) const;
|
||||
virtual char* convertUtf16ToUtf8(const char16_t* utf16In) const;
|
||||
|
||||
private:
|
||||
static char* STDCALL tempMemoryAllocation(unsigned long memoryNeeded);
|
||||
|
||||
private:
|
||||
ASEncoding encode; // file encoding conversion
|
||||
};
|
||||
|
||||
#endif // ASTYLE_LIB
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
} // end of namespace astyle
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// declarations for java native interface (JNI) build
|
||||
// they are called externally and are NOT part of the namespace
|
||||
//----------------------------------------------------------------------------
|
||||
#ifdef ASTYLE_JNI
|
||||
void STDCALL javaErrorHandler(int errorNumber, const char* errorMessage);
|
||||
char* STDCALL javaMemoryAlloc(unsigned long memoryNeeded);
|
||||
// the following function names are constructed from method names in the calling java program
|
||||
extern "C" EXPORT
|
||||
jstring STDCALL Java_AStyleInterface_AStyleGetVersion(JNIEnv* env, jclass);
|
||||
extern "C" EXPORT
|
||||
jstring STDCALL Java_AStyleInterface_AStyleMain(JNIEnv* env,
|
||||
jobject obj,
|
||||
jstring textInJava,
|
||||
jstring optionsJava);
|
||||
#endif // ASTYLE_JNI
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// declarations for UTF-16 interface
|
||||
// they are called externally and are NOT part of the namespace
|
||||
//----------------------------------------------------------------------------
|
||||
#ifdef ASTYLE_LIB
|
||||
extern "C" EXPORT
|
||||
char16_t* STDCALL AStyleMainUtf16(const char16_t* pSourceIn,
|
||||
const char16_t* pOptions,
|
||||
fpError fpErrorHandler,
|
||||
fpAlloc fpMemoryAlloc);
|
||||
#endif // ASTYLE_LIB
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// declarations for standard DLL interface
|
||||
// they are called externally and are NOT part of the namespace
|
||||
//-----------------------------------------------------------------------------
|
||||
#ifdef ASTYLE_LIB
|
||||
extern "C" EXPORT char* STDCALL AStyleMain(const char* pSourceIn,
|
||||
const char* pOptions,
|
||||
fpError fpErrorHandler,
|
||||
fpAlloc fpMemoryAlloc);
|
||||
extern "C" EXPORT const char* STDCALL AStyleGetVersion(void);
|
||||
#endif // ASTYLE_LIB
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif // closes ASTYLE_MAIN_H
|
||||
Loading…
Reference in New Issue