Add sys.builtin_module_names

For os.py.  Currently just do it by inspecting the set of modules
at the end of the runtime setup; CPython does it by examining the
"import inittab".

Required adding str comparison methods so they can be sorted.

bonus: add errno module.

src/runtime/builtin_modules/errno.cpp

+// Copyright (c) 2014 Dropbox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cmath>
+
+#include "core/types.h"
+#include "gc/collector.h"
+#include "runtime/gc_runtime.h"
+#include "runtime/inline/boxing.h"
+#include "runtime/types.h"
+#include "runtime/util.h"
+
+namespace pyston {
+
+BoxedModule* errno_module;
+
+void setupErrno() {
+    errno_module = createModule("errno", "__builtin__");
+}
+}

src/runtime/builtin_modules/sys.cpp

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <algorithm>
 #include <cmath>
 
 #include "core/types.h"
@@ -87,4 +88,16 @@ void setupSys() {
     sys_module->giveAttr("stdin", new BoxedFile(stdin));
     sys_module->giveAttr("stderr", new BoxedFile(stderr));
 }
+
+void setupSysEnd() {
+    BoxedTuple::GCVector builtin_module_names;
+    for (auto& p : sys_modules_dict->d) {
+        builtin_module_names.push_back(p.first);
+    }
+
+    std::sort<decltype(builtin_module_names)::iterator, PyLt>(builtin_module_names.begin(), builtin_module_names.end(),
+                                                              PyLt());
+
+    sys_module->giveAttr("builtin_module_names", new BoxedTuple(std::move(builtin_module_names)));
+}
 }

src/runtime/str.cpp

@@ -191,6 +191,46 @@ extern "C" BoxedString* strMul(BoxedString* lhs, BoxedInt* rhs) {
     return new BoxedString(buf);
 }
 
+extern "C" Box* strLt(BoxedString* lhs, Box* rhs) {
+    assert(lhs->cls == str_cls);
+
+    if (rhs->cls != str_cls)
+        return NotImplemented;
+
+    BoxedString* srhs = static_cast<BoxedString*>(rhs);
+    return boxBool(lhs->s < srhs->s);
+}
+
+extern "C" Box* strLe(BoxedString* lhs, Box* rhs) {
+    assert(lhs->cls == str_cls);
+
+    if (rhs->cls != str_cls)
+        return NotImplemented;
+
+    BoxedString* srhs = static_cast<BoxedString*>(rhs);
+    return boxBool(lhs->s <= srhs->s);
+}
+
+extern "C" Box* strGt(BoxedString* lhs, Box* rhs) {
+    assert(lhs->cls == str_cls);
+
+    if (rhs->cls != str_cls)
+        return NotImplemented;
+
+    BoxedString* srhs = static_cast<BoxedString*>(rhs);
+    return boxBool(lhs->s > srhs->s);
+}
+
+extern "C" Box* strGe(BoxedString* lhs, Box* rhs) {
+    assert(lhs->cls == str_cls);
+
+    if (rhs->cls != str_cls)
+        return NotImplemented;
+
+    BoxedString* srhs = static_cast<BoxedString*>(rhs);
+    return boxBool(lhs->s >= srhs->s);
+}
+
 extern "C" Box* strEq(BoxedString* lhs, Box* rhs) {
     assert(lhs->cls == str_cls);
 
@@ -201,6 +241,16 @@ extern "C" Box* strEq(BoxedString* lhs, Box* rhs) {
     return boxBool(lhs->s == srhs->s);
 }
 
+extern "C" Box* strNe(BoxedString* lhs, Box* rhs) {
+    assert(lhs->cls == str_cls);
+
+    if (rhs->cls != str_cls)
+        return boxBool(true);
+
+    BoxedString* srhs = static_cast<BoxedString*>(rhs);
+    return boxBool(lhs->s != srhs->s);
+}
+
 extern "C" Box* strLen(BoxedString* self) {
     assert(self->cls == str_cls);
 
@@ -572,7 +622,14 @@ void setupStr() {
     str_cls->giveAttr("__add__", new BoxedFunction(boxRTFunction((void*)strAdd, UNKNOWN, 2)));
     str_cls->giveAttr("__mod__", new BoxedFunction(boxRTFunction((void*)strMod, STR, 2)));
     str_cls->giveAttr("__mul__", new BoxedFunction(boxRTFunction((void*)strMul, UNKNOWN, 2)));
+
+    str_cls->giveAttr("__lt__", new BoxedFunction(boxRTFunction((void*)strLt, UNKNOWN, 2)));
+    str_cls->giveAttr("__le__", new BoxedFunction(boxRTFunction((void*)strLe, UNKNOWN, 2)));
+    str_cls->giveAttr("__gt__", new BoxedFunction(boxRTFunction((void*)strGt, UNKNOWN, 2)));
+    str_cls->giveAttr("__ge__", new BoxedFunction(boxRTFunction((void*)strGe, UNKNOWN, 2)));
     str_cls->giveAttr("__eq__", new BoxedFunction(boxRTFunction((void*)strEq, UNKNOWN, 2)));
+    str_cls->giveAttr("__ne__", new BoxedFunction(boxRTFunction((void*)strNe, UNKNOWN, 2)));
+
     str_cls->giveAttr("__getitem__", new BoxedFunction(boxRTFunction((void*)strGetitem, STR, 2)));
 
     str_cls->giveAttr("__iter__", new BoxedFunction(boxRTFunction((void*)strIter, typeFromClass(str_iterator_cls), 1)));

src/runtime/types.cpp

@@ -599,11 +599,14 @@ void setupRuntime() {
 
     setupBuiltins();
     setupMath();
+    setupErrno();
     setupTime();
     setupThread();
 
     setupCAPI();
 
+    setupSysEnd();
+
     TRACK_ALLOCATIONS = true;
 }
 

src/runtime/types.h

@@ -57,6 +57,8 @@ void setupBuiltins();
 void setupMath();
 void setupTime();
 void setupThread();
+void setupErrno();
+void setupSysEnd();
 
 BoxedDict* getSysModulesDict();
 BoxedList* getSysPath();

test/tests/str_functions.py

@@ -39,3 +39,17 @@ for c in "hello world":
 for i in xrange(1, 10):
     for j in xrange(1, 4):
         print ("a"*i).count("a"*j)
+
+def test_comparisons(a, b):
+    print "%s < %s = " % (a, b), a < b
+    print "%s <= %s = " % (a, b), a <= b
+    print "%s > %s = " % (a, b), a > b
+    print "%s >= %s = " % (a, b), a >= b
+    print "%s == %s = " % (a, b), a == b
+    print "%s != %s = " % (a, b), a != b
+test_comparisons("a", "a")
+test_comparisons("a", "A")
+test_comparisons("a", "aa")
+test_comparisons("ab", "aa")
+
+print sorted([str(i) for i in xrange(25)])