atria-tools/estyle
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[DEV] add {} in else and if when not set and add the good indentation of functions

Browse Source
This commit is contained in:
Edouard DUPIN 2017-12-24 15:49:10 +01:00
parent f634d4281f
commit d3921adc1c
7 changed files with 245 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
estyle/Generator.cpp
View File

@ -20,6 +20,17 @@ void estyle::Generator::offsetPush(int32_t _count) {
m_offsetStack.pushBack(_count);
m_offset += _count;
}
void estyle::Generator::offsetPushAuto() {
int32_t offset = 0;
for (int64_t iii=m_output.size()-1; iii>=0; --iii) {
if ( m_output[iii] == '\n'
|| m_output[iii] == '\t') {
break;
}
offset++;
}
offsetPush(offset-m_offset);
}
void estyle::Generator::offsetPop() {
m_offset -= m_offsetStack.back();
@ -309,6 +320,7 @@ int32_t estyle::Generator::process(int32_t _startId,
}
if (elem == estyle::lexer::EQUAL) {
addSpace();
m_output += "=";
continue;
}
@ -351,6 +363,13 @@ int32_t estyle::Generator::process(int32_t _startId,
m_output += getEndOfLine();
continue;
}
if (elem == estyle::lexer::ELEMENT_COMPLEX_TYPE) {
// complex type is special to generate...
etk::String type = generateType(iii);
addSpace();
m_output += type;
continue;
}
if (elem == estyle::lexer::RESERVED_IF) {
addSpace();
m_output += "if ";
@ -372,13 +391,64 @@ int32_t estyle::Generator::process(int32_t _startId,
}
}
offsetPop();
// Check if next action is inside {} or not ...
if (nextIs(iii+1, estyle::lexer::BRACE_IN) == true) {
// no need to add one ...
int32_t countAction = countCurrent(iii+1, estyle::lexer::tocken::SEMICOLON);
// TODO: need to remove .. if needed...
continue;
}
m_output += getEndOfLine();
addSpace();
m_output += "{";
indentationPush();
m_output += getEndOfLine();
int32_t sectionEnd = endOfAction(iii+1);
iii = process(iii+1, sectionEnd+2);
m_output += getEndOfLine();
indentationPop();
addSpace();
m_output += "}";
m_output += getEndOfLine();
continue;
}
if (elem == estyle::lexer::ELEMENT_FUNCTION) {
if (elem == estyle::lexer::RESERVED_ELSE) {
if (nextIs(iii+1, estyle::lexer::BRACE_IN) == true) {
int32_t countAction = countCurrent(iii+1, estyle::lexer::tocken::SEMICOLON);
addSpace();
m_output += "else";
continue;
}
if (nextIs(iii+1, estyle::lexer::RESERVED_IF) == true) {
addSpace();
m_output += "else";
continue;
}
m_output += getEndOfLine();
addSpace();
m_output += "{";
indentationPush();
m_output += getEndOfLine();
int32_t sectionEnd = endOfAction(iii+1);
iii = process(iii+1, sectionEnd+1);
m_output += getEndOfLine();
indentationPop();
addSpace();
m_output += "}";
m_output += getEndOfLine();
continue;
}
if ( elem == estyle::lexer::ELEMENT_FUNCTION
|| elem == estyle::lexer::ELEMENT_FUNCTION_DECLARATION) {
addSpace();
m_output += m_lexer.getData(iii);
m_output += " ";
offsetPush(m_lexer.getData(iii).size() + 2);
//offsetPush(m_lexer.getData(iii).size() + 2);
offsetPushAuto();
for (int64_t jjj=iii+1; jjj<m_lexer.size(); ++jjj) {
enum estyle::lexer::tocken elem = m_lexer.getTocken(jjj);
if (elem == estyle::lexer::RESERVED_NEW_LINE) {
@ -398,7 +468,7 @@ int32_t estyle::Generator::process(int32_t _startId,
addSpace();
m_output += m_lexer.getData(iii);
}
return m_lexer.size();
return _stopId+1;
}
// go ackward and find if previous is the corect type (remove) \n and empty space ==> not comment they need to add it (wrong place but not may job ...
bool estyle::Generator::previousIs(int64_t _pos, enum estyle::lexer::tocken _previousType) {
@ -414,6 +484,7 @@ bool estyle::Generator::previousIs(int64_t _pos, enum estyle::lexer::tocken _pre
bool estyle::Generator::nextIs(int64_t _pos, enum estyle::lexer::tocken _nextType) {
for (int32_t iii=_pos; iii<m_lexer.size(); ++iii) {
enum estyle::lexer::tocken elem = m_lexer.getTocken(iii);
ESTYLE_VERBOSE("check if next: " << _nextType << " on " << elem);
if (elem == estyle::lexer::RESERVED_NEW_LINE) {
continue;
}
@ -426,7 +497,7 @@ int64_t estyle::Generator::generateCondition(int64_t _pos) {
int32_t sectionEnd = endOfSection(_pos);
int32_t nbCondition = countCurrentLevelCondition(_pos);
if (nbCondition == 0) {
process(_pos, sectionEnd+1);
process(_pos, sectionEnd);
} else {
m_output += "( ";
offsetPush(5);
@ -442,12 +513,13 @@ int64_t estyle::Generator::generateCondition(int64_t _pos) {
offsetPush(5);
m_output += " " + m_lexer.getData(iii) + " ";
} else {
iii = process(iii, sectionEnd, estyle::lexer::AND_AND, estyle::lexer::OR_OR, estyle::lexer::PARENTHESE_IN);
iii = process(iii, sectionEnd, estyle::lexer::AND_AND, estyle::lexer::OR_OR, estyle::lexer::PARENTHESE_IN, estyle::lexer::PARENTHESE_OUT);
iii--;
}
}
offsetPop();
}
addSpace();
m_output += ")";
return sectionEnd;
}
@ -456,19 +528,22 @@ int64_t estyle::Generator::generateFunction(int64_t _pos) {
int32_t sectionEnd = endOfSection(_pos);
int32_t nbParameters = countCurrentParameters(_pos);
m_output += "(";
offsetPushAuto();
if (nbParameters == 0) {
process(_pos + 1, sectionEnd);
} else {
for (int64_t iii=_pos+1; iii<=sectionEnd; ++iii) {
iii = process(iii, sectionEnd, estyle::lexer::COMA);
if (nextIs(iii, estyle::lexer::PARENTHESE_OUT) == false) {
iii = process(iii, sectionEnd, estyle::lexer::COMA, estyle::lexer::PARENTHESE_OUT);
if (nextIs(iii-1, estyle::lexer::PARENTHESE_OUT) == false) {
m_output += ",";
m_output += getEndOfLine();
addSpace();
}
}
}
addSpace();
m_output += ")";
offsetPop();
return sectionEnd;
}
@ -499,6 +574,22 @@ int64_t estyle::Generator::endOfSection(int64_t _pos) {
}
return m_lexer.size();
}
int64_t estyle::Generator::endOfAction(int64_t _pos) {
ESTYLE_INFO(" " << m_lexer.getTocken(_pos) << " " << _pos << " [BEGIN]");
for (int64_t iii=_pos+1; iii < m_lexer.size(); ++iii) {
enum estyle::lexer::tocken elem = m_lexer.getTocken(iii);
if (elem == estyle::lexer::SEMICOLON) {
return iii;
}
if ( elem == estyle::lexer::PARENTHESE_IN
|| elem == estyle::lexer::BRACKET_IN
|| elem == estyle::lexer::BRACE_IN) {
iii = endOfSection(iii);
return iii;
}
}
return m_lexer.size();
}
int32_t estyle::Generator::countCurrent(int64_t _pos,
@ -550,6 +641,11 @@ int32_t estyle::Generator::countCurrentParameters(int64_t _pos) {
estyle::lexer::COMA);
}
int32_t estyle::Generator::countCurrentAction(int64_t _pos) {
return countCurrent(_pos,
estyle::lexer::SEMICOLON);
}
int32_t estyle::Generator::countCurrentLevelComa(int64_t _pos) {
int32_t out = 0;
@ -603,3 +699,24 @@ int32_t estyle::Generator::getWhileCondition(int64_t _pos) {
return m_lexer.size();
}
etk::String estyle::Generator::generateType(int64_t _pos) {
etk::String out;
enum estyle::lexer::tocken elem = m_lexer.getTocken(_pos);
if (elem == estyle::lexer::ELEMENT_COMPLEX_TYPE) {
etk::Vector<estyle::LexerElement> listElement = m_lexer.getSubList(_pos);
for (size_t iii=0; iii<listElement.size(); ++iii) {
enum estyle::lexer::tocken elem2 = listElement[iii].getTocken();
if (elem2 == estyle::lexer::RESERVED_NEW_LINE) {
continue;
}
if (iii != 0) {
out += " ";
}
out += m_lexer.getDataSource(listElement[iii].getStart(), listElement[iii].getStop());
}
} else {
out = m_lexer.getData(_pos);
}
return out;
}

4
estyle/Generator.hpp
View File

@ -31,6 +31,7 @@ namespace estyle {
int32_t m_offset = 0; //!< number od space needed after the indentation (used for the if / else if / while / functions ....)
etk::Vector<int32_t> m_offsetStack;
void offsetPush(int32_t _count);
void offsetPushAuto();
void offsetPop();
@ -51,6 +52,7 @@ namespace estyle {
etk::String getDoxygenOneLine();
etk::String getDoxygenNLine(const etk::String& _data);
int64_t endOfSection(int64_t _pos);
int64_t endOfAction(int64_t _pos);
int32_t countCurrent(int64_t _pos,
enum estyle::lexer::tocken _type1,
enum estyle::lexer::tocken _type2 = estyle::lexer::END_OF_FILE,
@ -58,12 +60,14 @@ namespace estyle {
enum estyle::lexer::tocken _type4 = estyle::lexer::END_OF_FILE);
int32_t countCurrentLevelCondition(int64_t _pos);
int32_t countCurrentParameters(int64_t _pos);
int32_t countCurrentAction(int64_t _pos);
int64_t generateCondition(int64_t _pos);
int64_t generateFunction(int64_t _pos);
bool previousIs(int64_t _pos, enum estyle::lexer::tocken _previousType);
bool nextIs(int64_t _pos, enum estyle::lexer::tocken _nextType);
int32_t countCurrentLevelComa(int64_t _pos);
int32_t getWhileCondition(int64_t _pos);
etk::String generateType(int64_t _pos);
};
}

94
estyle/lexer/Lexer.cpp
View File

@ -394,6 +394,9 @@ void estyle::Lexer::parse() {
if (nextChar == '=') {
m_list.pushBack(estyle::LexerElement(estyle::lexer::LESS_EQUAL, iii, iii+2));
iii++;
} else if (nextChar == '<') {
m_list.pushBack(estyle::LexerElement(estyle::lexer::LESS_LESS, iii, iii+2));
iii++;
} else {
m_list.pushBack(estyle::LexerElement(estyle::lexer::LESS, iii, iii+1));
}
@ -403,6 +406,9 @@ void estyle::Lexer::parse() {
if (nextChar == '=') {
m_list.pushBack(estyle::LexerElement(estyle::lexer::GREATER_EQUAL, iii, iii+2));
iii++;
} else if (nextChar == '>') {
m_list.pushBack(estyle::LexerElement(estyle::lexer::GREATER_GREATER, iii, iii+2));
iii++;
} else {
m_list.pushBack(estyle::LexerElement(estyle::lexer::GREATER, iii, iii+1));
}
@ -563,18 +569,32 @@ void estyle::Lexer::lexify(const etk::String& _input) {
parse();
postAnnalyse_namespace();
postAnnalyse_function();
postAnnalyse_function_typeExtern();
postAnnalyse_function_typeInternal();
ESTYLE_DEBUG("find:");
for (auto &it: m_list) {
ESTYLE_DEBUG(" '" << it.getTocken() << "' ==> '" << m_stream.extract(it.getStart(),it.getStop()) << "'");
if ( it.getTocken() == estyle::lexer::ELEMENT_COMPLEX
|| it.getTocken() == estyle::lexer::ELEMENT_COMPLEX_TYPE) {
ESTYLE_DEBUG(" '" << it.getTocken() << "'");
for (auto &it2: it.getList()) {
ESTYLE_DEBUG(" '" << it2.getTocken() << "' ==> '" << m_stream.extract(it2.getStart(),it2.getStop()) << "'");
}
} else {
ESTYLE_DEBUG(" '" << it.getTocken() << "' ==> '" << m_stream.extract(it.getStart(),it.getStop()) << "'");
}
}
}
etk::String estyle::Lexer::getDataSource(int32_t _start, int32_t _stop) const {
return m_stream.extract(_start, _stop);
}
etk::String estyle::Lexer::getData(int32_t _position) const {
return m_stream.extract(m_list[_position].getStart(), m_list[_position].getStop());
return getDataSource(m_list[_position].getStart(), m_list[_position].getStop());
}
etk::String estyle::Lexer::getValueString(int32_t _position) const {
return m_stream.extract(m_list[_position].getStart(), m_list[_position].getStop());
return getDataSource(m_list[_position].getStart(), m_list[_position].getStop());
}
ivec2 estyle::Lexer::getFilePosition(int32_t _position) const {
@ -600,7 +620,7 @@ etk::String estyle::Lexer::getFileLine(int32_t _position) const {
if (positionStart < 0) {
positionStart = 0;
}
for (;positionStop< m_stream.size(); ++positionStop) {
for (;positionStop < int64_t(m_stream.size()); ++positionStop) {
if (m_stream[positionStop] == '\n') {
break;
}
@ -665,4 +685,68 @@ void estyle::Lexer::postAnnalyse_function() {
}
++it;
}
}
}
void estyle::Lexer::postAnnalyse_function_typeExtern() {
for (int64_t iii=0; iii<m_list.size(); ++iii) {
if (m_list[iii].getTocken() == estyle::lexer::ELEMENT_FUNCTION) {
ESTYLE_WARNING("Find function ==> check if we have a type : '" << getData(iii) << "'");
// search backward the first element availlable like const/ID/*/&/
int64_t end = iii;
for (int64_t jjj=iii-1; jjj>=0; --jjj) {
auto elem = m_list[jjj].getTocken();
if ( elem == estyle::lexer::BASIC_TYPE_INTEGER_SIZE_T
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_008
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_008_UNSIGNED
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_016
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_016_UNSIGNED
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_032
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_032_UNSIGNED
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_064
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_064_UNSIGNED
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_128
|| elem == estyle::lexer::BASIC_TYPE_INTEGER_128_UNSIGNED
|| elem == estyle::lexer::BASIC_TYPE_FLOAT_32
|| elem == estyle::lexer::BASIC_TYPE_FLOAT_64
|| elem == estyle::lexer::BASIC_TYPE_FLOAT_96
|| elem == estyle::lexer::BASIC_TYPE_BOOLEAN
|| elem == estyle::lexer::BASIC_TYPE_VOID
|| elem == estyle::lexer::RESERVED_INT
|| elem == estyle::lexer::RESERVED_LONG
|| elem == estyle::lexer::RESERVED_SHORT
|| elem == estyle::lexer::RESERVED_SIGNED
|| elem == estyle::lexer::RESERVED_UNSIGNED
|| elem == estyle::lexer::RESERVED_CONST
|| elem == estyle::lexer::AND
|| elem == estyle::lexer::MULTIPLY
|| elem == estyle::lexer::GREATER
|| elem == estyle::lexer::GREATER_GREATER
|| elem == estyle::lexer::LESS
|| elem == estyle::lexer::RESERVED_NEW_LINE) {
continue;
}
// find the end
end = jjj+1;
break;
}
if (end == iii) {
// Function call ...
} else {
estyle::LexerElement tmp = estyle::LexerElement(estyle::lexer::ELEMENT_COMPLEX_TYPE, m_list[end].getStart(), m_list[iii-1].getStop());
for (int64_t jjj=end; jjj<iii; ++jjj) {
tmp.pushElement(m_list[jjj]);
}
m_list[end] = tmp;
m_list.eraseLen(end+1, iii-end-1);
iii = end+1;
m_list[iii].setTocken(estyle::lexer::ELEMENT_FUNCTION_DECLARATION);
ESTYLE_WARNING(" ==> type: '" << getData(end) << "'");
}
}
}
}
void estyle::Lexer::postAnnalyse_function_typeInternal() {
}

16
estyle/lexer/Lexer.hpp
View File

@ -39,6 +39,16 @@ namespace estyle {
void setStop(int32_t _pos) {
m_stop = _pos;
}
private:
//special case of complex element:
etk::Vector<estyle::LexerElement> m_list;
public:
void pushElement(const estyle::LexerElement& _element) {
m_list.pushBack(_element);
}
const etk::Vector<estyle::LexerElement>& getList() const {
return m_list;
}
};
class Lexer {
private:
@ -51,6 +61,8 @@ namespace estyle {
// squash element name space like "::lklkmlk" and "lmkmlk::lmkmlk::mlklk" in 1 element
void postAnnalyse_namespace();
void postAnnalyse_function();
void postAnnalyse_function_typeExtern();
void postAnnalyse_function_typeInternal();
public:
int64_t size() const {
return m_list.size();
@ -58,7 +70,11 @@ namespace estyle {
enum estyle::lexer::tocken getTocken(int32_t _position) const {
return m_list[_position].getTocken();
}
const etk::Vector<estyle::LexerElement>& getSubList(int32_t _position) const {
return m_list[_position].getList();
}
etk::String getData(int32_t _position) const;
etk::String getDataSource(int32_t _start, int32_t _stop) const;
etk::String getValueString(int32_t _position) const;
ivec2 getFilePosition(int32_t _position) const;
etk::String getFileLine(int32_t _position) const;

5
estyle/lexer/tocken.cpp
View File

@ -25,8 +25,10 @@ etk::String estyle::lexer::toString(estyle::lexer::tocken _token) {
case estyle::lexer::NOT: return "!";
case estyle::lexer::NOT_EQUAL: return "!=";
case estyle::lexer::LESS: return "<";
case estyle::lexer::LESS_LESS: return "<<";
case estyle::lexer::LESS_EQUAL: return "<=";
case estyle::lexer::GREATER: return ">";
case estyle::lexer::GREATER_GREATER: return ">>";
case estyle::lexer::GREATER_EQUAL: return ">=";
case estyle::lexer::PLUS: return "+";
case estyle::lexer::MINUS: return "-";
@ -124,6 +126,9 @@ etk::String estyle::lexer::toString(estyle::lexer::tocken _token) {
case estyle::lexer::BASIC_TYPE_VOID: return "void";
case estyle::lexer::ELEMENT_FUNCTION: return "FUNCTION";
case estyle::lexer::ELEMENT_FUNCTION_DECLARATION: return "FUNCTION_DECLARATION";
case estyle::lexer::ELEMENT_COMPLEX: return "COMPLEX";
case estyle::lexer::ELEMENT_COMPLEX_TYPE: return "COMPLEX_TYPE";
}
return etk::String("?[") + etk::toString(int32_t(_token)) + "]";
}

6
estyle/lexer/tocken.hpp
View File

@ -25,8 +25,10 @@ namespace estyle {
NOT, //!< element "!"
NOT_EQUAL, //!< element "!="
LESS, //!< element "<"
LESS_LESS, //!< element "<<"
LESS_EQUAL, //!< element "<="
GREATER, //!< element ">"
GREATER_GREATER, //!< element ">>"
GREATER_EQUAL, //!< element ">="
PLUS, //!< element "+"
MINUS, //!< element "-"
@ -131,8 +133,12 @@ namespace estyle {
// post annalyse element:
ELEMENT_FUNCTION, //!< all composed with an ID previous a (
ELEMENT_FUNCTION_DECLARATION, //!< all composed with an ID previous a ( ==> and have a type on the left
ELEMENT_COMPLEX, //!< complex type with multiple tocken inside
ELEMENT_COMPLEX_TYPE, //!< complex type with multiple tocken inside
BASIC_TYPE_LIST_END,
};
etk::String toString(estyle::lexer::tocken _token);

2
test/main.cpp
View File

@ -61,7 +61,7 @@ TEST(testrestyle, test3) {
etk::String source =
"namespace aaa { namespace BBB { const unsigned int myFunction(int32_t& arg1, float** arg2, const double*& arg3=0x345aeF);const unsigned int myFunction(int32_t& arg1, float** arg2, const double*& arg3){ return 0;} } } if(aaa::BBB::myFunction(2452452345!=55 && 765432=5432,24523452354,\"43SFGDVEZT5R34EAQCWX\") == false && 235445 & 24545 == 'R') exit (-1); if (ploppp == 54) { return -T;}";
"namespace aaa { namespace BBB { const unsigned \n int myFunction(int32_t & arg1, float \t*\t\t* arg2, const\t \n double*\n& arg3=0x345aeF);const unsigned int myFunction(int32_t& arg1, float** arg2, const double*& arg3){ return 0;} } } if(aaa::BBB::myFunction(2452452345!=55 && 765432=5432,24523452354,\"43SFGDVEZT5R34EAQCWX\") == false && 235445 & 24545 == 'R') exit (-1); if (ploppp == 54) { return -T;}";
etk::String output = interface.process(source);
TEST_INFO("source:\n" << source);