QStringList split_into_symbols(const QString &str) { QStringList ret; QStringList list1=str.split(QRegExp("\\s+"),QString::SkipEmptyParts); //split by white space for (int j=0; j<list1.count(); j++) { QString hold=list1[j]; while (hold.count()>0) { if (hold.count()>0) { if (is_initial_identifier_character(hold[0])) { int k=1; while ((k<hold.count())&&(is_identifier_character(hold[k]))) k++; ret << hold.mid(0,k); hold=hold.mid(k); } else if (is_initial_number_character(hold[0])) { int k=1; while ((k<hold.count())&&(is_number_character(hold[k]))) k++; ret << hold.mid(0,k); hold=hold.mid(k); } /*else if (hold[0]=='\"') { int k=1; bool last_character_was_escape=false; while ((k<hold.count())&&( (hold[k]!='\"') || (last_character_was_escape) )) { if (hold[k]=='\\') last_character_was_escape=!last_character_was_escape; else last_character_was_escape=false; k++; } if ((hold[k]=='\"')&&(!last_character_was_escape)) { ret << hold.mid(0,k+1); hold=hold.mid(k+1); } else { ret << hold.mid(0,k); hold=hold.mid(k); } }*/ else { ret << QString(hold[0]); hold=hold.mid(1); } } } } return ret; }
// -------------------------------------------------------------------------- // obfuscate_identifier -- Obfuscate the identifier to be read from the file // and leave it in the lookahead buffer. void JavaScript_Juicer::obfuscate_identifier( void ) { // avoids constant buffer reallocation m_obfuscation_temp_string.clear(); for( ; ; ) { int c = read_next_character(); if( is_identifier_character( c ) ) { m_obfuscation_temp_string.push_back( c ); } else { m_lookahead_buffer.push_back( c ); break; } } if( m_obfuscation_temp_string.size() <= 1 ) { std::vector<char>::reverse_iterator it = m_obfuscation_temp_string.rbegin(); while(it != m_obfuscation_temp_string.rend()) m_lookahead_buffer.push_back( *it++ ); return; // leave the /$./ identifier unmodified. } // In a single lookup either find or add an entry for this identifier. std::pair<Obfuscation_Table::iterator, bool> insertion = m_obfuscation_table.insert( Obfuscation_Table::value_type( m_obfuscation_temp_string, std::vector<char>() ) ); if( insertion.second == true ) { // Identifier did not already exist, so generate it's obfuscation. insertion.first->second = generate_obfuscation_id(); } std::vector<char>& obfuscated_identifier = insertion.first->second; // m_obfuscation_temp_string was actually generated backwards, so this works out correctly. for( int i=0; i != obfuscated_identifier.size(); ++i ) { // insert was breaking on VC6. m_lookahead_buffer.push_back( obfuscated_identifier[i] ); } }
void JavaScript_Juicer::minimize_file( void ) { m_b_was_deleted = false; m_a = '\n'; minimize_character( DELETE_B ); minimize_character( DELETE_A ); while( m_a != EOF ) { switch( m_a ) { case ' ': { if( is_identifier_character( m_b ) || m_b == '@' ) { minimize_character( EMIT_A ); } else { minimize_character( DELETE_A ); } break; } case '\n': { switch( m_b ) { case '{': case '[': case '(': case '+': case '-': minimize_character( EMIT_A ); break; case ' ': minimize_character( DELETE_B ); break; default: if( is_identifier_character( m_b ) ) { minimize_character( EMIT_A ); } else { minimize_character( DELETE_A ); } } break; } default: { switch( m_b ) { case ' ': if( is_identifier_character( m_a ) ) { minimize_character( EMIT_A ); break; } minimize_character( DELETE_B ); break; case '\n': switch( m_a ) { case '}': case ']': case ')': case '+': case '-': case '"': case '\'': case '/': // possible end of conditional comment. minimize_character( EMIT_A ); break; default: if( is_identifier_character( m_a ) ) { minimize_character( EMIT_A ); } else { minimize_character( DELETE_B ); } } break; default: minimize_character( EMIT_A ); break; } } } } }