/* 针对lua中出现的对话选项后面紧跟其执行的函数名这种情况进行特殊处理,
因为抽取出来的字符串往往包含了对话其后的函数名,需要去掉,否则一旦翻
译的时候他们把函数名写错了,问题将非常大 */
int
get_tail_func_name_len(char* pBuffer, int nStrLen){
char cOld, *pStr;
int nLen = 0;
int nIsFuncName = 1;
cOld = pBuffer[nStrLen];
pBuffer[nStrLen] = '\0';
pStr = strrchr(pBuffer, '/');
if (pStr != NULL){
nLen = nStrLen - (int)(pStr - pBuffer);
pStr++;
if ( *pStr != '#'){
while ( *pStr != '\0' ){
if ( (!is_letter(*pStr)) &&
(!is_digit(*pStr)) &&
(!is_ungderline(*pStr))&&
(!is_bracket(*pStr)) ){
nIsFuncName = 0;
break;
}
pStr++;
}
}
if ( nIsFuncName == 0 )
nLen = 0;
}
pBuffer[nStrLen] = cOld;
return nLen;
}
void recursion(string s){
int n;
for(int i=0;i<s.size();i++){
if(s[i]==')'){
n = i-1;
break;
}
}
for(int i=n;i<s.size()-1;i++){
if(s[i+1]=='('){
return;
}
string s_tmp = s;
// swap
char c = s_tmp[n];
s_tmp[n] = s_tmp[i+1];
s_tmp[i+1] = c;
if(is_bracket(s_tmp)){
recursion(s_tmp);
// save
save_str.push_back(s_tmp);
}
}
}
string sinsp_filter::next_operand(bool expecting_first_operand)
{
int32_t start;
//
// Skip spaces
//
if(isblank(m_fltstr[m_scanpos]))
{
next();
}
//
// Mark the beginning of the word
//
start = m_scanpos;
for(; m_scanpos < m_scansize; m_scanpos++)
{
char curchar = m_fltstr[m_scanpos];
bool is_end_of_word;
if(expecting_first_operand)
{
is_end_of_word = (isblank(curchar) || is_special_char(curchar));
}
else
{
is_end_of_word = (isblank(curchar) || is_bracket(curchar));
}
if(is_end_of_word)
{
//
// End of word
//
ASSERT(m_scanpos > start);
string res = m_fltstr.substr(start, m_scanpos - start);
if(curchar == '(' || curchar == ')')
{
m_scanpos--;
}
return res;
}
}
//
// End of filter
//
return m_fltstr.substr(start, m_scansize - 1);
}
vector<char> sinsp_filter::next_operand(bool expecting_first_operand)
{
vector<char> res;
bool is_quoted = false;
int32_t start;
int32_t nums[2];
uint32_t num_pos;
enum ppm_escape_state
{
PES_NORMAL,
PES_SLASH,
PES_NUMBER,
PES_ERROR,
} escape_state;
//
// Skip spaces
//
if(isblank(m_fltstr[m_scanpos]))
{
next();
}
//
// If there are quotes, don't stop on blank
//
if(m_scanpos < m_scansize &&
(m_fltstr[m_scanpos] == '"' || m_fltstr[m_scanpos] == '\''))
{
is_quoted = true;
m_scanpos++;
}
//
// Mark the beginning of the word
//
start = m_scanpos;
escape_state = PES_NORMAL;
num_pos = 0;
while(m_scanpos < m_scansize && escape_state != PES_ERROR)
{
char curchar = m_fltstr[m_scanpos];
bool is_end_of_word;
if(expecting_first_operand)
{
is_end_of_word = (isblank(curchar) || is_special_char(curchar));
}
else
{
is_end_of_word = (!is_quoted && (isblank(curchar) || is_bracket(curchar))) ||
(is_quoted && escape_state != PES_SLASH && (curchar == '"' || curchar == '\''));
}
if(is_end_of_word)
{
if(escape_state != PES_NORMAL)
{
escape_state = PES_ERROR;
break;
}
//
// End of word
//
ASSERT(m_scanpos > start);
if(curchar == '(' || curchar == ')')
{
m_scanpos--;
}
res.push_back('\0');
return res;
}
switch(escape_state)
{
case PES_NORMAL:
if(curchar == '\\' && !expecting_first_operand)
{
escape_state = PES_SLASH;
}
else
{
res.push_back(curchar);
}
break;
case PES_SLASH:
switch(curchar)
{
case '\\':
case '"':
escape_state = PES_NORMAL;
res.push_back(curchar);
break;
case 'x':
escape_state = PES_NUMBER;
break;
default:
escape_state = PES_ERROR;
break;
}
break;
case PES_NUMBER:
if(isdigit((int)curchar))
{
nums[num_pos++] = curchar - '0';
}
else if((curchar >= 'a' && curchar <= 'f') || (curchar >= 'A' && curchar <= 'F'))
{
nums[num_pos++] = tolower((int)curchar) - 'a' + 10;
}
else
{
escape_state = PES_ERROR;
}
if(num_pos == 2 && escape_state != PES_ERROR)
{
res.push_back((char)(nums[0] * 16 + nums[1]));
num_pos = 0;
escape_state = PES_NORMAL;
}
break;
default:
ASSERT(false);
escape_state = PES_ERROR;
break;
}
m_scanpos++;
}
if(escape_state == PES_ERROR)
{
throw sinsp_exception("filter error: unrecognized escape sequence at " + m_fltstr.substr(start, m_scanpos));
}
else if(is_quoted)
{
throw sinsp_exception("filter error: unclosed quotes");
}
//
// End of filter
//
res.push_back('\0');
return res;
}
std::list<token> to_rpn(const std::list<token>& tokens)
{
std::list<token> rpn_tokens;
std::list<token> temp_stack;
token::type last_type = token::type::none;
std::for_each(tokens.begin(), tokens.end(), [&](const token& t) {
switch (t.get_type()) {
case token::type::number:
{
rpn_tokens.push_back(t);
}
break;
case token::type::opening_bracket:
{
if(last_type == token::type::closing_bracket) {
throw std::runtime_error("Invalid tokens: missed operator");
}
temp_stack.push_back(t);
}
break;
case token::type::closing_bracket:
{
auto temp_t = t;
while(temp_t.get_type() != token::type::opening_bracket) {
if(temp_stack.empty()) {
throw std::runtime_error("Invalid tokens: incorrectly placed separator or not agreed brackets");
}
temp_t = temp_stack.back();
temp_stack.pop_back();
if(!temp_t.is_bracket()) {
rpn_tokens.push_back(temp_t);
}
}
}
break;
default:
if(!t.is_operator()) {
throw std::runtime_error("Invalid token type");
}
auto priority = token::get_operator_priority(t.get_type());
while (!temp_stack.empty()) {
auto temp_t = temp_stack.back();
if (temp_t.is_operator()) {
auto temp_priority = token::get_operator_priority(temp_t.get_type());
if (priority <= temp_priority) {
rpn_tokens.push_back(temp_t);
temp_stack.pop_back();
}
else {
break;
}
}
else {
break;
}
}
temp_stack.push_back(t);
break;
}
last_type = t.get_type();
});
while(!temp_stack.empty()) {
auto temp_t = temp_stack.back();
temp_stack.pop_back();
if(temp_t.get_type() == token::type::opening_bracket || temp_t.get_type() == token::type::closing_bracket) {
throw std::runtime_error("Invalid tokens: not agreed brackets");
}
rpn_tokens.push_back(temp_t);
}
return rpn_tokens;
}
