rabix
/
RedPanda-CPP
mirror of https://github.com/Reduced-panda/RedPanda-CPP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove astyle sourcetree

This commit is contained in:
Roy Qu 2024-04-25 16:29:27 +08:00
parent 055f08e647
commit 7df90b0d5d
22 changed files with 70 additions and 21039 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
RedPandaIDE/RedPandaIDE.pro
View File

@ -157,6 +157,7 @@ SOURCES += \
settingsdialog/environmentshortcutwidget.cpp \
settingsdialog/executorproblemsetwidget.cpp \
settingsdialog/formattergeneralwidget.cpp \
settingsdialog/formatterpathwidget.cpp \
settingsdialog/languageasmgenerationwidget.cpp \
# settingsdialog/languagecformatwidget.cpp \
settingsdialog/projectcompileparamaterswidget.cpp \
@ -291,6 +292,7 @@ HEADERS += \
settingsdialog/environmentshortcutwidget.h \
settingsdialog/executorproblemsetwidget.h \
settingsdialog/formattergeneralwidget.h \
settingsdialog/formatterpathwidget.h \
settingsdialog/languageasmgenerationwidget.h \
# settingsdialog/languagecformatwidget.h \
settingsdialog/projectcompileparamaterswidget.h \
@ -390,6 +392,7 @@ FORMS += \
settingsdialog/environmentshortcutwidget.ui \
settingsdialog/executorproblemsetwidget.ui \
settingsdialog/formattergeneralwidget.ui \
settingsdialog/formatterpathwidget.ui \
settingsdialog/languageasmgenerationwidget.ui \
# settingsdialog/languagecformatwidget.ui \
settingsdialog/projectcompileparamaterswidget.ui \
@ -520,17 +523,6 @@ win32: {
settingsdialog/projectversioninfowidget.cpp
}
unix: {
HEADERS += \
settingsdialog/formatterpathwidget.h
SOURCES += \
settingsdialog/formatterpathwidget.cpp
FORMS += \
settingsdialog/formatterpathwidget.ui
}
linux: {
# legacy glibc compatibility -- modern Unices have all components in `libc.so`
LIBS += -lrt -ldl

9
RedPandaIDE/editor.cpp
View File

@ -5107,30 +5107,21 @@ void Editor::reformat(bool doReparse)
{
if (readOnly())
return;
#ifndef Q_OS_WIN
if (!fileExists(pSettings->environment().AStylePath())) {
QMessageBox::critical(this,
tr("astyle not found"),
tr("Can't find astyle in \"%1\".").arg(pSettings->environment().AStylePath()));
return;
}
#endif
//we must remove all breakpoints and syntax issues
// onLinesDeleted(1,lineCount());
QByteArray content = text().toUtf8();
QStringList args = pSettings->codeFormatter().getArguments();
//qDebug()<<args;
#ifdef Q_OS_WIN
QByteArray newContent = runAndGetOutput("astyle.exe",
pSettings->dirs().appDir(),
args,
content);
#else
QByteArray newContent = runAndGetOutput(pSettings->environment().AStylePath(),
extractFileDir(pSettings->environment().AStylePath()),
args,
content);
#endif
if (newContent.isEmpty())
return;
replaceContent(QString::fromUtf8(newContent), doReparse);

40
RedPandaIDE/settings.cpp
View File

@ -3785,12 +3785,33 @@ void Settings::Environment::doLoad()
// check saved terminal path
mTerminalPath = stringValue("terminal_path", "");
// always do substitution for backward compatibility
mTerminalPath.replace("%*APP_DIR*%",pSettings->dirs().appDir());
mTerminalPath = replacePrefix(mTerminalPath, "%*APP_DIR*%", pSettings->dirs().appDir());
mTerminalArgumentsPattern = stringValue("terminal_arguments_pattern", "");
checkAndSetTerminal();
mAStylePath = includeTrailingPathDelimiter(pSettings->dirs().appLibexecDir())+"astyle";
mAStylePath = stringValue("astyle_path","");
if (mAStylePath.isEmpty()) {
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
QString path = env.value("PATH");
QStringList pathList = path.split(PATH_SEPARATOR);
pathList = QStringList{
mSettings->dirs().appDir(),
mSettings->dirs().appLibexecDir(),
} + pathList;
foreach (const QString& folder, pathList) {
QDir dir{folder};
QFileInfo fileInfo{dir.absoluteFilePath(ASTYLE_PROGRAM)};
if (fileInfo.exists()) {
mAStylePath = fileInfo.absoluteFilePath();
break;
}
}
if (isGreenEdition())
mAStylePath = replacePrefix(mAStylePath, pSettings->dirs().appDir() , "%*APP_DIR*%");
}
mHideNonSupportFilesInFileView=boolValue("hide_non_support_files_file_view",true);
mOpenFilesInSingleInstance = boolValue("open_files_in_single_instance",false);
}
@ -3857,12 +3878,17 @@ void Settings::Environment::setTerminalPath(const QString &terminalPath)
QString Settings::Environment::AStylePath() const
{
if (isGreenEdition()) {
return replacePrefix(mAStylePath, "%*APP_DIR*%", pSettings->dirs().appDir());
}
return mAStylePath;
}
void Settings::Environment::setAStylePath(const QString &aStylePath)
{
mAStylePath = aStylePath;
if (isGreenEdition())
mAStylePath = replacePrefix(mAStylePath, pSettings->dirs().appDir() , "%*APP_DIR*%");
}
QString Settings::Environment::terminalArgumentsPattern() const
@ -3943,7 +3969,7 @@ void Settings::Environment::checkAndSetTerminal()
QList<TerminalItem> terminalList = loadTerminalList();
for (const TerminalItem& termItem:terminalList) {
QString term=termItem.terminal;
term.replace("%*APP_DIR*%",pSettings->dirs().appDir());
term = replacePrefix(term, "%*APP_DIR*%", pSettings->dirs().appDir());
QFileInfo info{term};
QString absoluteTerminalPath;
if (info.isAbsolute()) {
@ -4001,7 +4027,7 @@ QList<Settings::Environment::TerminalItem> Settings::Environment::loadTerminalLi
QString termExecutable = QFileInfo(path).fileName();
QString pattern = terminal["argsPattern"].toString();
Settings::Environment::TerminalItem terminalItem;
path.replace("%*APP_DIR*%", pSettings->dirs().appDir());
path = replacePrefix(path, "%*APP_DIR*%", pSettings->dirs().appDir());
terminalItem.terminal = path;
terminalItem.param = pattern;
result.append(terminalItem);
@ -4060,9 +4086,7 @@ void Settings::Environment::doSave()
// APP_DIR trick for windows portable app
// For non-portable app (other platform or Windows installer), multiple instances
// share the same configuration and thus the trick may break terminal path
if (terminalPath.startsWith(pSettings->dirs().appDir())) {
terminalPath="%*APP_DIR*%"+terminalPath.mid(pSettings->dirs().appDir().length());
}
terminalPath = replacePrefix(terminalPath, pSettings->dirs().appDir(), "%*APP_DIR*%");
}
saveValue("terminal_path",terminalPath);
@ -4070,7 +4094,7 @@ void Settings::Environment::doSave()
#ifdef Q_OS_WINDOWS
saveValue("use_custom_terminal",mUseCustomTerminal);
#endif
saveValue("asyle_path",mAStylePath);
saveValue("astyle_path",mAStylePath);
saveValue("hide_non_support_files_file_view",mHideNonSupportFilesInFileView);
saveValue("open_files_in_single_instance",mOpenFilesInSingleInstance);

7
RedPandaIDE/settingsdialog/formattergeneralwidget.cpp
View File

@ -328,17 +328,10 @@ void FormatterGeneralWidget::updateDemo()
Settings::CodeFormatter formatter(nullptr);
updateCodeFormatter(formatter);
#ifdef Q_OS_WIN
QByteArray newContent = runAndGetOutput("astyle.exe",
pSettings->dirs().appDir(),
formatter.getArguments(),
content);
#else
QByteArray newContent = runAndGetOutput(pSettings->environment().AStylePath(),
extractFileDir(pSettings->environment().AStylePath()),
formatter.getArguments(),
content);
#endif
ui->editDemo->document()->setText(newContent);
}

6
RedPandaIDE/settingsdialog/settingsdialog.cpp
View File

@ -41,6 +41,7 @@
#include "executorproblemsetwidget.h"
#include "debuggeneralwidget.h"
#include "formattergeneralwidget.h"
#include "formatterpathwidget.h"
#include "languageasmgenerationwidget.h"
#include "projectgeneralwidget.h"
#include "projectfileswidget.h"
@ -59,9 +60,6 @@
#include "environmentfileassociationwidget.h"
#include "projectversioninfowidget.h"
#endif
#if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS) // XDG desktop
#include "formatterpathwidget.h"
#endif
#include <QDebug>
#include <QMessageBox>
#include <QModelIndex>
@ -228,10 +226,8 @@ PSettingsDialog SettingsDialog::optionDialog()
widget = new FormatterGeneralWidget(tr("General"),tr("Code Formatter"));
dialog->addWidget(widget);
#if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS) // XDG desktop
widget = new FormatterPathWidget(tr("Program"),tr("Code Formatter"));
dialog->addWidget(widget);
#endif
widget = new ToolsGeneralWidget(tr("General"),tr("Tools"));
dialog->addWidget(widget);

2
RedPandaIDE/systemconsts.h
View File

@ -40,6 +40,7 @@
#define SDCC_PROGRAM "sdcc.exe"
#define PACKIHX_PROGRAM "packihx.exe"
#define MAKEBIN_PROGRAM "makebin.exe"
#define ASTYLE_PROGRAM "astyle.exe"
#else // Unix
#define CONSOLE_PAUSER "consolepauser"
#define GCC_PROGRAM "gcc"
@ -61,6 +62,7 @@
#define SDCC_PROGRAM "sdcc"
#define PACKIHX_PROGRAM "packihx"
#define MAKEBIN_PROGRAM "makebin"
#define ASTYLE_PROGRAM "astyle"
#endif
#define DEV_PROJECT_EXT "dev"

4
Red_Panda_CPP.pro
View File

@ -2,13 +2,11 @@ TEMPLATE = subdirs
SUBDIRS += \
RedPandaIDE \
astyle \
consolepauser \
redpanda_qt_utils \
qsynedit \
lua
astyle.subdir = tools/astyle
consolepauser.subdir = tools/consolepauser
redpanda_qt_utils.subdir = libs/redpanda_qt_utils
qsynedit.subdir = libs/qsynedit
@ -16,7 +14,7 @@ lua.subdir = libs/lua
# Add the dependencies so that the RedPandaIDE project can add the depended programs
# into the main app bundle
RedPandaIDE.depends = astyle consolepauser qsynedit
RedPandaIDE.depends = consolepauser qsynedit
qsynedit.depends = redpanda_qt_utils
APP_NAME = RedPandaCPP

9
libs/redpanda_qt_utils/qt_utils/utils.cpp
View File

@ -752,3 +752,12 @@ int compareFileModifiedTime(const QString &filename, qint64 timestamp)
return -1;
return 0;
}
QString replacePrefix(const QString &oldString, const QString &prefix, const QString &newPrefix)
{
QString result = oldString;
if (oldString.startsWith(prefix)) {
result = newPrefix+oldString.mid(prefix.length());
}
return result;
}

2
libs/redpanda_qt_utils/qt_utils/utils.h
View File

@ -143,6 +143,8 @@ QString generateAbsolutePath(const QString& dirPath, const QString& relativePath
QStringList absolutePaths(const QString& dirPath, const QStringList& relativePaths);
QString escapeSpacesInString(const QString& str);
QString replacePrefix(const QString& oldString, const QString& prefix, const QString& newPrefix);
bool isReadOnly(const QString& filename);

3
packages/debian/control
View File

@ -18,7 +18,8 @@ Depends: ${shlibs:Depends},
g++,
make,
gdb,
gdbserver
gdbserver,
astyle
Recommends: qterminal | deepin-terminal | konsole | gnome-terminal | terminator | lxterminal | mate-terminal | terminology | xfce4-terminal | alacritty | cool-retro-term | kitty | sakura | termit | tilix
Description: A lightweight but powerful C/C++ IDE
Red Panda C++ (Old name Red Panda Dev-C++ 7) is a full featured C/C++ IDE.

19
packages/msys/build-mingw.sh
View File

@ -121,6 +121,8 @@ while [[ $# -gt 0 ]]; do
esac
done
ASTYLE_BUILD_DIR="${TEMP}/astyle-build"
ASTYLE_VERSION_TAG="3.4.14"
BUILD_DIR="${TEMP}/redpanda-mingw-${MSYSTEM}-build"
PACKAGE_DIR="${TEMP}/redpanda-mingw-${MSYSTEM}-pkg"
QMAKE="${MINGW_PREFIX}/qt5-static/bin/qmake"
@ -158,7 +160,7 @@ if [[ ${CHECK_DEPS} -eq 1 ]]; then
;;
esac
deps=(
${MINGW_PACKAGE_PREFIX}-{$compiler,make,qt5-static,7zip}
${MINGW_PACKAGE_PREFIX}-{$compiler,make,qt5-static,7zip,cmake}
mingw-w64-i686-nsis
git
)
@ -184,10 +186,23 @@ fi
if [[ ${CLEAN} -eq 1 ]]; then
rm -rf "${BUILD_DIR}"
rm -rf "${PACKAGE_DIR}"
rm -rf "${ASTYLE_BUILD_DIR}"
fi
mkdir -p "${BUILD_DIR}" "${PACKAGE_DIR}" "${TARGET_DIR}"
mkdir -p "${BUILD_DIR}" "${PACKAGE_DIR}" "${TARGET_DIR}" "${ASTYLE_BUILD_DIR}"
## build
fn_print_progress "Building astyle..."
pushd .
cd "${ASTYLE_BUILD_DIR}"
[[ -d "astyle" ]] || git clone --depth 1 --branch "${ASTYLE_VERSION_TAG}" "https://gitlab.com/saalen/astyle"
cd astyle
[[ ! -d "build" ]] || rm -rf "build"
mkdir build
cd build
cmake .. -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXE_LINKER_FLAGS="-static"
mingw32-make -j$(nproc)
cp AStyle/AStyle.exe "${PACKAGE_DIR}/astyle.exe"
popd
fn_print_progress "Building..."
pushd .

3747
tools/astyle/ASBeautifier.cpp
View File

File diff suppressed because it is too large Load Diff

775
tools/astyle/ASEnhancer.cpp
View File

@ -1,775 +0,0 @@
// 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

8367
tools/astyle/ASFormatter.cpp
View File

File diff suppressed because it is too large Load Diff

1168
tools/astyle/ASLocalizer.cpp
View File

File diff suppressed because it is too large Load Diff

172
tools/astyle/ASLocalizer.h
View File

@ -1,172 +0,0 @@
// 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

805
tools/astyle/ASResource.cpp
View File

@ -1,805 +0,0 @@
// 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_THREEWAY_COMPARISION = 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(&macro);
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 = 16;
// 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);
nonAssignmentOperators->emplace_back(&AS_THREEWAY_COMPARISION);
// 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_THREEWAY_COMPARISION);
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;
if ((unsigned char) ch > 127)
return true;
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');
}
bool ASBase::isHexDigit(char ch) const
{
return (ch >= '0' && ch <= '9')
|| (ch >= 'a' && ch <= 'f')
|| (ch >= 'A' && ch <= 'F');
}
bool ASBase::isLetterOrUnderLine(char ch) const
{ return (ch >= 'a' && ch <= 'z')
|| (ch >= 'A' && ch <= 'Z')
|| (ch == '_');
}
// 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

1096
tools/astyle/astyle.h
View File

File diff suppressed because it is too large Load Diff

53
tools/astyle/astyle.pro
View File

@ -1,53 +0,0 @@
QT -= gui
isEmpty(APP_NAME) {
APP_NAME = RedPandaCPP
}
CONFIG += c++11 console
CONFIG -= app_bundle
msvc {
CONFIG += windows
}
# 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
isEmpty(PREFIX) {
PREFIX = /usr/local
}
isEmpty(LIBEXECDIR) {
LIBEXECDIR = $${PREFIX}/libexec
}
win32: {
!isEmpty(PREFIX) {
target.path = $${PREFIX}
}
}
win32-msvc {
QMAKE_CFLAGS += /source-charset:utf-8
QMAKE_CXXFLAGS += /source-charset:utf-8
}
# Default rules for deployment.
qnx: target.path = $${LIBEXECDIR}/$${APP_NAME}
else: unix:!android: target.path = $${LIBEXECDIR}/$${APP_NAME}
!isEmpty(target.path): INSTALLS += target
HEADERS += \
ASLocalizer.h \
astyle.h \
astyle_main.h

4360
tools/astyle/astyle_main.cpp
View File

File diff suppressed because it is too large Load Diff

429
tools/astyle/astyle_main.h
View File

@ -1,429 +0,0 @@
// 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

20
tools/astyle/xmake.lua
View File

@ -1,20 +0,0 @@
target("astyle")
set_kind("binary")
add_options("mingw-static")
if is_os("windows") then
add_links("shell32")
end
add_files(
"ASBeautifier.cpp",
"ASEnhancer.cpp",
"ASFormatter.cpp",
"ASLocalizer.cpp",
"ASResource.cpp",
"astyle_main.cpp")
if is_xdg() then
on_install(install_libexec)
end