making jython-2.1 available for scripting

1 files changed, 252 insertions, 0 deletions

diff --git a/lib/jython/Lib/test/pystone.py b/lib/jython/Lib/test/pystone.py
new file mode 100644
index 000000000..a77532d46
--- /dev/null
+++ b/lib/jython/Lib/test/pystone.py
@@ -0,0 +1,252 @@
+#! /usr/bin/env python

+

+"""

+"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 = 10000

+

+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():

+    benchtime, stones = pystones()

+    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 = map(lambda x: x[:], [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

+    return benchtime, (loops / benchtime)

+

+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__':

+    main()