Use format instead of stringstream in Regex

diff --git a/source/strings/regex.cpp b/source/strings/regex.cpp
index 5ee2fcc5cf926d76e10b3a1b46a7912092e46d9c..03bf7dde64a8c786bcf6ac0449589835d36f797d 100644 (file)
--- a/source/strings/regex.cpp
+++ b/source/strings/regex.cpp
@@ -497,7 +497,7 @@ bool Regex::group_compare(const RegMatch::Group &g1, const RegMatch::Group &g2)
 
 string Regex::disassemble() const
 {
 
 string Regex::disassemble() const
 {

-       ostringstream ss;
+       string result;

 
        for(Code::const_iterator i=code.begin(); i!=code.end();)
        {
 
        for(Code::const_iterator i=code.begin(); i!=code.end();)
        {


@@ -507,76 +507,69 @@ string Regex::disassemble() const
                string bytes;
                for(; j!=i; ++j)
                        bytes += format(" %02X", static_cast<int>(*j)&0xFF);
                string bytes;
                for(; j!=i; ++j)
                        bytes += format(" %02X", static_cast<int>(*j)&0xFF);

-               ss<<Fmt("%3d")<<offset<<':'<<Fmt("%-9s")<<bytes;
+               result += format("%3d:%-9s  ", offset, bytes);

                if(bytes.size()>9)
                if(bytes.size()>9)

-                       ss<<"\n"<<Fmt("%15s");
-               ss<<"  "<<decompiled<<'\n';
+                       result += "\n               ";
+               result += decompiled;
+               result += '\n';

        }
 
        }
 

-       return ss.str();
+       return result;

 }
 
 string Regex::disassemble_instruction(Code::const_iterator &i) const
 {
        Instruction instr = static_cast<Instruction>(*i++);
 
 }
 
 string Regex::disassemble_instruction(Code::const_iterator &i) const
 {
        Instruction instr = static_cast<Instruction>(*i++);
 

-       ostringstream result;

        switch(instr)
        {
        case JUMP:
                {
                        Offset offset = read_int<Offset>(i);
        switch(instr)
        {
        case JUMP:
                {
                        Offset offset = read_int<Offset>(i);

-                       result<<"JUMP "<<Fmt("%+d")<<offset<<" ("<<Fmt("%d")<<i-code.begin()+offset<<')';
+                       return format("JUMP %+d (%d)", offset, (i-code.begin())+offset);

                }
                }

-               break;

        case ND_JUMP:
                {
                        Offset offset = read_int<Offset>(i);
        case ND_JUMP:
                {
                        Offset offset = read_int<Offset>(i);

-                       result<<"ND_JUMP "<<Fmt("%+d")<<offset<<" ("<<Fmt("%d")<<i-code.begin()+offset<<')';
+                       return format("ND_JUMP %+d (%d)", offset, (i-code.begin())+offset);

                }
                }

-               break;

        case GROUP_BEGIN:
        case GROUP_BEGIN:

-               result<<"GROUP_BEGIN "<<read_int<Index>(i);
-               break;
+               return format("GROUP_BEGIN %d", read_int<Index>(i));

        case GROUP_END:
        case GROUP_END:

-               result<<"GROUP_END "<<read_int<Index>(i);
-               break;
+               return format("GROUP_END %d", read_int<Index>(i));

        case NEGATE:
        case NEGATE:

-               result<<"NEGATE";
-               break;
+               return "NEGATE";

        case MATCH_BEGIN:
        case MATCH_BEGIN:

-               result<<"MATCH_BEGIN";
-               break;
+               return "MATCH_BEGIN";

        case MATCH_END:
        case MATCH_END:

-               result<<"MATCH_END";
-               break;
+               return "MATCH_END";

        case MATCH_CHAR:
                {
                        char c = *i++;
        case MATCH_CHAR:
                {
                        char c = *i++;

-                       result<<"MATCH_CHAR ";

                        if(c>=0x20 && c<=0x7E)
                        if(c>=0x20 && c<=0x7E)

-                               result<<'\''<<c<<'\'';
+                               return format("MATCH_CHAR '%c'", c);

                        else
                        else

-                               result<<(static_cast<int>(c)&0xFF);
+                               return format("MATCH_CHAR %d", static_cast<int>(c)&0xFF);

                }
                break;
        case MATCH_RANGE:
                }
                break;
        case MATCH_RANGE:

-               result<<"MATCH_RANGE "<<(static_cast<int>(*i++)&0xFF);
-               result<<'-'<<(static_cast<int>(*i++)&0xFF);
-               break;
+               {
+                       int begin = *i++;
+                       int end = *i++;
+                       return format("MATCH_RANGE %d-%d", begin&0xFF, end&0xFF);
+               }

        case MATCH_MASK:
        case MATCH_MASK:

-               result<<"MATCH_MASK";
-               for(unsigned j=0; j<32; ++j)
-                       result<<' '<<Fmt("%02X")<<(static_cast<int>(*i++)&0xFF);
-               break;
+               {
+                       string result = "MATCH_MASK";
+                       for(unsigned j=0; j<32; ++j)
+                               result += format(" %02X", static_cast<int>(*i++)&0xFF);
+                       return result;
+               }

        case MATCH_ANY:
        case MATCH_ANY:

-               result<<"MATCH_ANY";
-               break;
+               return "MATCH_ANY";

        default:
        default:

-               result<<"UNKNOWN "<<instr;
+               return format("UNKNOWN %d", instr);

        }
        }

-
-       return result.str();

 }
 
 } // namespace Msp
 }
 
 } // namespace Msp