Fixed parsing bug, added unit tests, debug cleanup.0.12

There was an issue with order of operations outside of parenthesies,
easily solved.

1 files changed, 100 insertions, 0 deletions

diff --git a/src/options.cpp b/src/options.cpp
index d88df3b..26f0cb7 100644
--- a/src/options.cpp
+++ b/src/options.cpp
@@ -39,6 +39,8 @@ Options::Options( int argc, char *argv[] ) :
         "your shell).");

     addOption( Bu::slot(this, &Options::sum), "sum",

         "Read numbers from standard input and sum them, output the result.");

+    addOption( Bu::slot(this, &Options::grind), 'g', "grind",

+        "Search for magic numbers.  Secret magic numbers.");

     addOption( Bu::slot(this, &Options::version), 'v', "version",

         "Show the version string ('" CLIC_VERSION_STR "')");

     addHelpOption('h', "help", "This help");

@@ -224,3 +226,101 @@ int Options::version( Bu::StringArray aArgs )
     return 0;

 }

 

+bool onlyNines( const Bu::String &s )

+{

+    for( Bu::String::const_iterator i = s.begin(); i; i++ )

+    {

+        if( *i != '9' )

+            return false;

+    }

+    return true;

+}

+

+bool onlyOnes( const Bu::String &s )

+{

+    for( Bu::String::const_iterator i = s.begin(); i; i++ )

+    {

+        if( *i != '1' )

+            return false;

+    }

+    return true;

+}

+

+int Options::grind( Bu::StringArray aArgs )

+{

+    Number test("1");

+    Number bit("1");

+    Number mult("2");

+    int64_t iBits = 1;

+    int iLastSize = 0;

+

+    if( aArgs.getSize() > 1 )

+    {

+        Bu::print("Loading number..."); Bu::sioRaw.flush();

+        Bu::String num = Bu::File(aArgs[1], Bu::File::Read).readAll();

+        test = num;

+        Bu::println("done.");

+        Bu::print("Computing bit..."); Bu::sioRaw.flush();

+        bit = test;

+        bit = bit+Number("1");

+        bit = bit/mult;

+        Bu::println("done.");

+        if( aArgs.getSize() > 2 )

+        {

+            Bu::print("Trusting a human for where we are..."); Bu::sioRaw.flush();

+            iBits = strtoll( aArgs[2].getStr(), NULL, 10 );

+        }

+        else

+        {

+            Bu::print("Figuring out where we are..."); Bu::sioRaw.flush();

+            Bu::String sBin = bit.toRadix(2).toString();

+            iBits = sBin.getSize();

+        }

+//        Bu::println("Done.  Checking.");

+//        Bu::println("test = %1, bit = %2").arg( test ).arg( bit );

+//        Bu::String sTest = test.toRadix(2).toString();

+//        Bu::File("check-bit.txt", Bu::File::WriteNew ).write( sBin );

+//        Bu::File("check-test.txt", Bu::File::WriteNew ).write( sTest );

+        iLastSize = num.getSize();

+//        Bu::println("File written. %1 bits").arg( sBin.getSize() );

+        Bu::println("done.");

+        Bu::println("Continuing calculation...");

+    }

+

+    for(;;)

+    {

+        bit = bit*mult;

+        test = test + bit;

+        Bu::String r = test.toString();

+        iBits++;

+

+        if( onlyNines(r) )

+        {

+            Bu::println("%1 digits").arg( r.getSize() );

+            Bu::File f("answer-dec.txt", Bu::File::WriteNew );

+            f.write( r );

+            Bu::println("Success.");

+//            Bu::println("%1 == %2").arg( test.toRadix(2) ).arg( r );

+            return 0;

+        }

+        if( r.getSize() != iLastSize && r.getSize()%1000 == 0 )

+        {

+            /*

+            Bu::String rs = test.toRadix(2).toString();

+            int iOBits = rs.getSize();

+            if( iOBits != iBits )

+                Bu::println("Bit mismatch: %1 vs %2").arg( iOBits ).arg( iBits );

+            if( !onlyOnes( rs ) )

+                Bu::println("Not only ones!");

+                */

+            iLastSize = r.getSize();

+            Bu::println("%1 digits").arg( r.getSize() );

+            Bu::File f(Bu::String("interum-%1-%2.txt").arg( r.getSize() ).arg( iBits ), Bu::File::WriteNew );

+            f.write( r );

+        }

+    }

+    Bu::println("Failure.");

+    exit( 0 );

+    return 0;    

+}

+