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;
}
}
}
}
}
