Add LICENSE, README and examples

Author: ncw

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2018 Nick Craig-Wood
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,66 @@
+# gpython
+
+gpython is a part re-implementation / part port of the Python 3.4
+interpreter to the Go language, "batteries not included".
+
+It includes:
+
+  * runtime - using compatible byte code to python3.4
+  * lexer
+  * parser
+  * compiler
+  * interactive mode (REPL)
+
+It does not include very many python modules as many of the core
+modules are written in C not python.  The converted modules are:
+
+  * builtins
+  * marshal
+  * math
+  * time
+  * sys
+
+## Objectives
+
+Gpython was written as a learning experiment to investigate how hard
+porting Python to Go might be.  It turns out that all those C modules
+are a significant barrier to making a fully functional port.
+
+## Status
+
+The project works well enough to parse all the code in the python 3.4
+distribution and to compile and run python 3 programs which don't
+depend on a module gpython doesn't support.
+
+See the examples directory for some python programs which run with
+gpython.
+
+Speed hasn't been a goal of the conversions however it runs pystone at
+about 20% of the speed of cpython.  The pi test runs quicker under
+gpython as I think the Go long integer primitives are faster than the
+Python ones.
+
+There are many directions this project could go in.  I think the most
+profitable would be to re-use the
+[grumpy](https://github.com/google/grumpy) runtime (which would mean
+changing the object model).  This would give access to the C modules
+that need to be ported and would give grumpy access to a compiler and
+interpreter (gpython does support `eval` for instance).
+
+I (@ncw) haven't had much time to work on gpython (I started it in
+2013 and have worked on it very sporadically) so someone who wants to
+take it in the next direction would be much appreciated.
+
+## Limitations and Bugs
+
+Lots!
+
+## Similar projects
+
+  * [grumpy](https://github.com/google/grumpy) - a python to go transpiler
+
+## License
+
+This is licensed under the MIT licence, however it contains code which
+was ported fairly directly directly from the cpython source code under
+the (PSF LICENSE)[https://github.com/python/cpython/blob/master/LICENSE)

examples/pi_chudnovsky_bs.py

@@ -0,0 +1,105 @@
+"""
+Python3 program to calculate Pi using python long integers, binary
+splitting and the Chudnovsky algorithm
+
+See: http://www.craig-wood.com/nick/articles/ FIXME for explanation
+
+Nick Craig-Wood <nick@craig-wood.com>
+"""
+
+import math
+from time import time
+
+def sqrt(n, one):
+    """
+    Return the square root of n as a fixed point number with the one
+    passed in.  It uses a second order Newton-Raphson convgence.  This
+    doubles the number of significant figures on each iteration.
+    """
+    # Use floating point arithmetic to make an initial guess
+    floating_point_precision = 10**16
+    n_float = float((n * floating_point_precision) // one) / floating_point_precision
+    x = (int(floating_point_precision * math.sqrt(n_float)) * one) // floating_point_precision
+    n_one = n * one
+    while 1:
+        x_old = x
+        x = (x + n_one // x) // 2
+        if x == x_old:
+            break
+    return x
+
+
+def pi_chudnovsky_bs(digits):
+    """
+    Compute int(pi * 10**digits)
+
+    This is done using Chudnovsky's series with binary splitting
+    """
+    C = 640320
+    C3_OVER_24 = C**3 // 24
+    def bs(a, b):
+        """
+        Computes the terms for binary splitting the Chudnovsky infinite series
+
+        a(a) = +/- (13591409 + 545140134*a)
+        p(a) = (6*a-5)*(2*a-1)*(6*a-1)
+        b(a) = 1
+        q(a) = a*a*a*C3_OVER_24
+
+        returns P(a,b), Q(a,b) and T(a,b)
+        """
+        if b - a == 1:
+            # Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)
+            if a == 0:
+                Pab = Qab = 1
+            else:
+                Pab = (6*a-5)*(2*a-1)*(6*a-1)
+                Qab = a*a*a*C3_OVER_24
+            Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)
+            if a & 1:
+                Tab = -Tab
+        else:
+            # Recursively compute P(a,b), Q(a,b) and T(a,b)
+            # m is the midpoint of a and b
+            m = (a + b) // 2
+            # Recursively calculate P(a,m), Q(a,m) and T(a,m)
+            Pam, Qam, Tam = bs(a, m)
+            # Recursively calculate P(m,b), Q(m,b) and T(m,b)
+            Pmb, Qmb, Tmb = bs(m, b)
+            # Now combine
+            Pab = Pam * Pmb
+            Qab = Qam * Qmb
+            Tab = Qmb * Tam + Pam * Tmb
+        return Pab, Qab, Tab
+    # how many terms to compute
+    DIGITS_PER_TERM = math.log10(C3_OVER_24/6/2/6)
+    N = int(digits/DIGITS_PER_TERM + 1)
+    # Calclate P(0,N) and Q(0,N)
+    P, Q, T = bs(0, N)
+    one = 10**digits
+    sqrtC = sqrt(10005*one, one)
+    return (Q*426880*sqrtC) // T
+
+# The last 5 digits or pi for various numbers of digits
+check_digits = (
+        (100, 70679),
+       (1000,  1989),
+      (10000, 75678),
+     (100000, 24646),
+    (1000000, 58151),
+   (10000000, 55897),
+)
+
+if __name__ == "__main__":
+    digits = 100
+    pi = pi_chudnovsky_bs(digits)
+    print(str(pi))
+    for digits, check in check_digits:
+        start =time()
+        pi = pi_chudnovsky_bs(digits)
+        print("chudnovsky_gmpy_bs: digits",digits,"time",time()-start)
+        last_five_digits = pi % 100000
+        if check == last_five_digits:
+            print("Last 5 digits %05d OK" % last_five_digits)
+        else:
+            print("Last 5 digits %05d wrong should be %05d" % (last_five_digits, check))

examples/pystone.py

@@ -0,0 +1,271 @@
+#! /usr/bin/env python3
+
+"""
+"PYSTONE" Benchmark Program
+
+Version:        Python/1.1 (corresponds to C/1.1 plus 2 Pystone fixes)
+
+Author:         Reinhold P. Weicker,  CACM Vol 27, No 10, 10/84 pg. 1013.
+
+                Translated from ADA to C by Rick Richardson.
+                Every method to preserve ADA-likeness has been used,
+                at the expense of C-ness.
+
+                Translated from C to Python by Guido van Rossum.
+
+Version History:
+
+                Version 1.1 corrects two bugs in version 1.0:
+
+                First, it leaked memory: in Proc1(), NextRecord ends
+                up having a pointer to itself.  I have corrected this
+                by zapping NextRecord.PtrComp at the end of Proc1().
+
+                Second, Proc3() used the operator != to compare a
+                record to None.  This is rather inefficient and not
+                true to the intention of the original benchmark (where
+                a pointer comparison to None is intended; the !=
+                operator attempts to find a method __cmp__ to do value
+                comparison of the record).  Version 1.1 runs 5-10
+                percent faster than version 1.0, so benchmark figures
+                of different versions can't be compared directly.
+
+"""
+
+LOOPS = 50000
+
+from time import clock
+
+__version__ = "1.1"
+
+[Ident1, Ident2, Ident3, Ident4, Ident5] = range(1, 6)
+
+class Record:
+
+    def __init__(self, PtrComp = None, Discr = 0, EnumComp = 0,
+                       IntComp = 0, StringComp = 0):
+        self.PtrComp = PtrComp
+        self.Discr = Discr
+        self.EnumComp = EnumComp
+        self.IntComp = IntComp
+        self.StringComp = StringComp
+
+    def copy(self):
+        return Record(self.PtrComp, self.Discr, self.EnumComp,
+                      self.IntComp, self.StringComp)
+
+TRUE = 1
+FALSE = 0
+
+def main(loops=LOOPS):
+    benchtime, stones = pystones(loops)
+    print("Pystone(%s) time for %d passes = %g" % \
+          (__version__, loops, benchtime))
+    print("This machine benchmarks at %g pystones/second" % stones)
+
+
+def pystones(loops=LOOPS):
+    return Proc0(loops)
+
+IntGlob = 0
+BoolGlob = FALSE
+Char1Glob = '\0'
+Char2Glob = '\0'
+Array1Glob = [0]*51
+Array2Glob = [x[:] for x in [Array1Glob]*51]
+PtrGlb = None
+PtrGlbNext = None
+
+def Proc0(loops=LOOPS):
+    global IntGlob
+    global BoolGlob
+    global Char1Glob
+    global Char2Glob
+    global Array1Glob
+    global Array2Glob
+    global PtrGlb
+    global PtrGlbNext
+
+    starttime = clock()
+    for i in range(loops):
+        pass
+    nulltime = clock() - starttime
+
+    PtrGlbNext = Record()
+    PtrGlb = Record()
+    PtrGlb.PtrComp = PtrGlbNext
+    PtrGlb.Discr = Ident1
+    PtrGlb.EnumComp = Ident3
+    PtrGlb.IntComp = 40
+    PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"
+    String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
+    Array2Glob[8][7] = 10
+
+    starttime = clock()
+
+    for i in range(loops):
+        Proc5()
+        Proc4()
+        IntLoc1 = 2
+        IntLoc2 = 3
+        String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"
+        EnumLoc = Ident2
+        BoolGlob = not Func2(String1Loc, String2Loc)
+        while IntLoc1 < IntLoc2:
+            IntLoc3 = 5 * IntLoc1 - IntLoc2
+            IntLoc3 = Proc7(IntLoc1, IntLoc2)
+            IntLoc1 = IntLoc1 + 1
+        Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3)
+        PtrGlb = Proc1(PtrGlb)
+        CharIndex = 'A'
+        while CharIndex <= Char2Glob:
+            if EnumLoc == Func1(CharIndex, 'C'):
+                EnumLoc = Proc6(Ident1)
+            CharIndex = chr(ord(CharIndex)+1)
+        IntLoc3 = IntLoc2 * IntLoc1
+        IntLoc2 = IntLoc3 / IntLoc1
+        IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1
+        IntLoc1 = Proc2(IntLoc1)
+
+    benchtime = clock() - starttime - nulltime
+    if benchtime == 0.0:
+        loopsPerBenchtime = 0.0
+    else:
+        loopsPerBenchtime = (loops / benchtime)
+    return benchtime, loopsPerBenchtime
+
+def Proc1(PtrParIn):
+    PtrParIn.PtrComp = NextRecord = PtrGlb.copy()
+    PtrParIn.IntComp = 5
+    NextRecord.IntComp = PtrParIn.IntComp
+    NextRecord.PtrComp = PtrParIn.PtrComp
+    NextRecord.PtrComp = Proc3(NextRecord.PtrComp)
+    if NextRecord.Discr == Ident1:
+        NextRecord.IntComp = 6
+        NextRecord.EnumComp = Proc6(PtrParIn.EnumComp)
+        NextRecord.PtrComp = PtrGlb.PtrComp
+        NextRecord.IntComp = Proc7(NextRecord.IntComp, 10)
+    else:
+        PtrParIn = NextRecord.copy()
+    NextRecord.PtrComp = None
+    return PtrParIn
+
+def Proc2(IntParIO):
+    IntLoc = IntParIO + 10
+    while 1:
+        if Char1Glob == 'A':
+            IntLoc = IntLoc - 1
+            IntParIO = IntLoc - IntGlob
+            EnumLoc = Ident1
+        if EnumLoc == Ident1:
+            break
+    return IntParIO
+
+def Proc3(PtrParOut):
+    global IntGlob
+
+    if PtrGlb is not None:
+        PtrParOut = PtrGlb.PtrComp
+    else:
+        IntGlob = 100
+    PtrGlb.IntComp = Proc7(10, IntGlob)
+    return PtrParOut
+
+def Proc4():
+    global Char2Glob
+
+    BoolLoc = Char1Glob == 'A'
+    BoolLoc = BoolLoc or BoolGlob
+    Char2Glob = 'B'
+
+def Proc5():
+    global Char1Glob
+    global BoolGlob
+
+    Char1Glob = 'A'
+    BoolGlob = FALSE
+
+def Proc6(EnumParIn):
+    EnumParOut = EnumParIn
+    if not Func3(EnumParIn):
+        EnumParOut = Ident4
+    if EnumParIn == Ident1:
+        EnumParOut = Ident1
+    elif EnumParIn == Ident2:
+        if IntGlob > 100:
+            EnumParOut = Ident1
+        else:
+            EnumParOut = Ident4
+    elif EnumParIn == Ident3:
+        EnumParOut = Ident2
+    elif EnumParIn == Ident4:
+        pass
+    elif EnumParIn == Ident5:
+        EnumParOut = Ident3
+    return EnumParOut
+
+def Proc7(IntParI1, IntParI2):
+    IntLoc = IntParI1 + 2
+    IntParOut = IntParI2 + IntLoc
+    return IntParOut
+
+def Proc8(Array1Par, Array2Par, IntParI1, IntParI2):
+    global IntGlob
+
+    IntLoc = IntParI1 + 5
+    Array1Par[IntLoc] = IntParI2
+    Array1Par[IntLoc+1] = Array1Par[IntLoc]
+    Array1Par[IntLoc+30] = IntLoc
+    for IntIndex in range(IntLoc, IntLoc+2):
+        Array2Par[IntLoc][IntIndex] = IntLoc
+    Array2Par[IntLoc][IntLoc-1] = Array2Par[IntLoc][IntLoc-1] + 1
+    Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc]
+    IntGlob = 5
+
+def Func1(CharPar1, CharPar2):
+    CharLoc1 = CharPar1
+    CharLoc2 = CharLoc1
+    if CharLoc2 != CharPar2:
+        return Ident1
+    else:
+        return Ident2
+
+def Func2(StrParI1, StrParI2):
+    IntLoc = 1
+    while IntLoc <= 1:
+        if Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1:
+            CharLoc = 'A'
+            IntLoc = IntLoc + 1
+    if CharLoc >= 'W' and CharLoc <= 'Z':
+        IntLoc = 7
+    if CharLoc == 'X':
+        return TRUE
+    else:
+        if StrParI1 > StrParI2:
+            IntLoc = IntLoc + 7
+            return TRUE
+        else:
+            return FALSE
+
+def Func3(EnumParIn):
+    EnumLoc = EnumParIn
+    if EnumLoc == Ident3: return TRUE
+    return FALSE
+
+if __name__ == '__main__':
+    import sys
+    def error(msg):
+        print(msg, end=' ', file=sys.stderr)
+        print("usage: %s [number_of_loops]" % sys.argv[0], file=sys.stderr)
+        sys.exit(100)
+    print(sys.argv)
+    nargs = len(sys.argv) - 1
+    if nargs > 1:
+        error("%d arguments are too many;" % nargs)
+    elif nargs == 1:
+        try: loops = int(sys.argv[1])
+        except ValueError:
+            error("Invalid argument %r;" % sys.argv[1])
+    else:
+        loops = LOOPS
+    main(loops)

notes.txt

@@ -21,6 +21,7 @@ Things to do before release
     * frame.Lasti is pointing past the instruction which puts tracebacks out
   * Subclass builtins
   * pygen
+  * consider whether to re-use the grumpy runtime
 
 FIXME recursive types for __repr__ in list, dict, tuple
 >>> L=[0]