benchmarks/languages/benches/bench_base.nit

   1 #!/usr/bin/env nit
   2 # This file is part of NIT ( http://www.nitlanguage.org ).
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 # Microbenchmak generation for multiple language
  17 # Just a quick an dirty Nit script file :)
  18
  19 # This benchmark focuses on effects of the hierarchy dept
  20 # on the typetest performances
  21
  22 # class Root
  23 # class Klass[E] super Root
  24 # class C1...CX super Root
  25 # Klass[CX] isa Klass[C1]
  26
  27 class Klass
  28         var id: Int
  29         var supers = new Array[Klass]
  30         var all_supers = new HashSet[Klass]
  31         redef fun to_s
  32         do
  33                 return "C{id}"
  34         end
  35 end
  36
  37 class Generator
  38
  39         var classes = new Array[Klass]
  40
  41         var dept = 5 is writable
  42         var loops = 50000 is writable
  43         var middle = 0 is writable
  44         var dry = false is writable
  45         var check = false is writable
  46
  47         # Polymorphism level
  48         # This is the number of distinct dynamic types for the receiver
  49         var poly = 2 is writable
  50
  51         # Use only interfaces (or traits) in the hierarchy
  52         #
  53         # If `false` then java&cs&scala will use classes, thus will break if MH is used
  54         var use_interfaces = true is writable
  55
  56         # Add Root0, the superclass to Root that introduce common services.
  57         #
  58         # This add another level of un-optimization since the services are not introduced
  59         # by the static type of the receiver.
  60         var use_root0 = true is writable
  61
  62         fun genhier
  63         do
  64                 var s: nullable Klass = null
  65                 for d in [1..dept] do
  66                         var c = new Klass(d)
  67
  68                         classes.add(c)
  69                         c.all_supers.add(c)
  70                         if s != null then
  71                                 c.supers.add(s)
  72                                 c.all_supers.add_all(s.all_supers)
  73                         end
  74                         s = c
  75                 end
  76                 middle = (dept) / 2
  77         end
  78
  79         var file: nullable FileWriter = null
  80         fun write(str: String)
  81         do
  82                 file.write(str)
  83                 file.write("\n")
  84         end
  85
  86         fun initnit(res: Array[String]) do return
  87         fun testnit: String do return "true"
  88
  89         fun writenit(dir: String, name: String)
  90         do
  91                 var ia = new Array[String]
  92                 initnit(ia)
  93                 if ia.is_empty then
  94                         print "Nit disabled"
  95                         return
  96                 end
  97
  98                 dir = "{dir}/nit"
  99                 dir.mkdir
 100                 file = new FileWriter.open("{dir}/{name}.nit")
 101
 102                 if use_root0 then
 103                         write "class Root0"
 104                 else
 105                         write "class Root"
 106                 end
 107                 write "\tfun id: Int do return 0"
 108                 write "\tvar aid: Int = id"
 109                 write "\tvar next: Root is noautoinit"
 110                 write "\tfun set_next(next: Root): Root do\n\t\tself.next = next\n\t\treturn next\n\tend"
 111                 write "end"
 112                 if use_root0 then
 113                         write "class Root\n\tsuper Root0\nend"
 114                 end
 115                 for c in classes do
 116                         write "class {c}[E]"
 117                         if c.supers.is_empty then
 118                                 write "\tsuper Root"
 119                         else for s in c.supers do
 120                                 write "\tsuper {s}[E]"
 121                         end
 122                         write "\tredef fun id do return {c.id}"
 123                         write "\tfun f{c.id}: Int do return {c.id}"
 124                         write "\tvar a{c.id}: Int = {c.id}"
 125                         write "end"
 126                 end
 127
 128                 write "fun test(a,b: Root, loops, start: Int)"
 129                 write "do"
 130                 write "var x = start"
 131                 write "var i = loops"
 132                 write "while i > 0 do"
 133                 write "\tvar j = loops"
 134                 write "\twhile j > 0 do"
 135                 var test = "x >= 0"
 136                 if not dry then test = testnit
 137                 write "\t\tif {test} then"
 138                 write "\t\t\tvar tmp = a; a = b; b = tmp"
 139                 if check then write "\t\tx += 1"
 140                 write "\t\telse"
 141                 write "\t\t\tx += 1"
 142                 write "\t\t\ta = a.next"
 143                 write "\t\t\tb = b.next"
 144                 write "\t\tend"
 145                 write "\t\tj -= 1"
 146                 write "\tend"
 147                 write "\tx += 1"
 148                 write "\ta = a.next"
 149                 write "\tb = b.next"
 150                 write "\ti -= 1"
 151                 write "end"
 152                 write "print x"
 153                 write "end"
 154
 155                 write "var b: Root = {ia.first}"
 156                 write "var tmp = b"
 157                 for i in ia do
 158                         write "b = b.set_next({i})"
 159                 end
 160                 write "b.next = tmp"
 161                 write "var a: Root = {ia.last}"
 162                 write "tmp = a"
 163                 for i in [1..poly[ do
 164                         write "a = a.set_next({ia[ia.length - 1 - i]})"
 165                 end
 166                 write "a.next = tmp"
 167                 write "test(b, b.next, 10, -100)"
 168                 write "test(a, a.next, {loops}, 0)"
 169
 170                 file.close
 171         end
 172
 173         fun initjava(res: Array[String], interfaces: Bool) do return
 174         fun testjava(interfaces: Bool): String do return "true"
 175         fun writejava(dir: String, name: String, interfaces: Bool)
 176         do
 177                 var ia = new Array[String]
 178                 initjava(ia, interfaces)
 179                 if ia.is_empty then
 180                         print "Java disabled"
 181                         return
 182                 end
 183
 184                 dir = "{dir}/java"
 185                 dir.mkdir
 186                 file = new FileWriter.open("{dir}/{name}.java")
 187
 188                 write "class {name} \{"
 189                 var root0 = "Root"
 190                 if use_root0 then root0 = "Root0"
 191                 if interfaces then
 192                         write "static interface {root0} \{ long id(); Root getNext(); Root setNext(Root next); \}"
 193                         write "static class XRoot implements {root0} \{"
 194                 else
 195                         write "static class {root0} \{"
 196                 end
 197                 write "\tpublic long id() \{ return 0;\}"
 198                 write "\tpublic long aid = id();"
 199                 write "\tpublic Root next;"
 200                 write "\tpublic Root getNext() \{ return next;\}"
 201                 write "\tpublic Root setNext(Root next) \{ this.next = next; return next; \}"
 202                 write "\}"
 203
 204                 if use_root0 then
 205                         if interfaces then
 206                                 write "static interface Root extends Root0 \{\}"
 207                         else
 208                                 write "static class Root extends Root0 \{\}"
 209                         end
 210                 end
 211
 212                 for c in classes do
 213                         if interfaces then
 214                                 write "static interface {c}<E> "
 215                         else
 216                                 write "static class {c}<E> "
 217                         end
 218                         if c.supers.is_empty then
 219                                 write "\textends Root"
 220                         else for s in [c.supers.first] do
 221                                 write "\textends {s}<E>"
 222                         end
 223                         if interfaces then
 224                                 write "\{\}"
 225                                 if c.supers.is_empty then
 226                                         write "static class X{c}<E> extends XRoot implements {c}<E>"
 227                                 else
 228                                         write "static class X{c}<E> extends X{c.supers.first}<E> implements {c}<E>"
 229                                 end
 230                         end
 231                         write "\{"
 232                         write "\tpublic long id() \{ return {c.id}; \}"
 233                         write "\tpublic long f{c.id}() \{ return {c.id}; \}"
 234                         write "\tpublic long a{c.id} = {c.id};"
 235                         write "\}"
 236                 end
 237
 238                 write "static public void main(String args[]) \{"
 239                 write "\tRoot b = {ia.first};"
 240                 write "\tRoot tmp = b;"
 241                 for i in ia do
 242                         write "\tb = b.setNext({i});"
 243                 end
 244                 write "\tb.setNext(tmp);"
 245                 write "\tRoot a = {ia.last};"
 246                 write "\ttmp = a;"
 247                 for i in [1..poly[ do
 248                         write "\ta = a.setNext({ia[ia.length - 1 - i]});"
 249                 end
 250                 write "\ta.setNext(tmp);"
 251                 write "\ttest(b, b.getNext(), 10, -100);"
 252                 write "\ttest(a, a.getNext(), {loops}, 0);"
 253                 write "\}"
 254
 255                 write "static public void test(Root a, Root b, long loops, long start) \{"
 256                 write "\tlong x = start;"
 257                 write "\tfor(long i = loops; i > 0; i--) \{"
 258                 write "\t\tfor(long j = loops; j > 0; j--) \{"
 259                 var test = "x>=0"
 260                 if not dry then test = testjava(interfaces)
 261                 write "\t\t\tif({test}) \{"
 262                 write "\t\t\t\tRoot tmp = a; a = b; b = tmp;"
 263                 if check then write "\t\t\t\tx = x + 1;"
 264                 write "\t\t\t\} else \{ x++; a = a.getNext(); b = b.getNext(); \}"
 265                 write "\t\t\}"
 266                 write "\t\tx++; a = a.getNext(); b = b.getNext();"
 267                 write "\t\}"
 268                 write "\tSystem.out.println(x);"
 269                 write "\}"
 270                 write "\}"
 271                 file.close
 272         end
 273
 274         fun initcsharp(res: Array[String], interfaces: Bool) do return
 275         fun testcsharp(interfaces: Bool): String do return "true"
 276         fun writecsharp(dir: String, name: String, interfaces: Bool)
 277         do
 278                 var ia = new Array[String]
 279                 initcsharp(ia, interfaces)
 280                 if ia.is_empty then
 281                         print "C# disabled"
 282                         return
 283                 end
 284
 285                 dir = "{dir}/cs"
 286                 dir.mkdir
 287                 file = new FileWriter.open("{dir}/{name}.cs")
 288
 289                 write "class {name} \{"
 290                 var root0 = "Root"
 291                 if use_root0 then root0 = "Root0"
 292                 if interfaces then
 293                         write "interface {root0} \{ long Id(); Root GetNext(); Root SetNext(Root next); \}"
 294                         write "class XRoot: {root0} \{ "
 295                 else
 296                         write "class {root0}\n\t\{ "
 297                 end
 298                 write "\tvirtual public long Id() \{ return 0; \}"
 299                 write "\tpublic long aid;"
 300                 write "\tpublic Root next;"
 301                 write "\tvirtual public Root GetNext() \{ return next; \}"
 302                 write "\tvirtual public Root SetNext(Root next) \{ this.next = next; return next; \}"
 303                 write "\}"
 304
 305                 if use_root0 then
 306                         if interfaces then
 307                                 write "interface Root: Root0 \{\}"
 308                         else
 309                                 write "class Root: Root0 \{\}"
 310                         end
 311                 end
 312
 313                 for c in classes do
 314                         var cname
 315                         if interfaces then
 316                                 write "interface {c}<out E> "
 317                                 cname = "X"+c.to_s
 318                         else
 319                                 write "class {c}<E> "
 320                                 cname = c.to_s
 321                         end
 322                         if c.supers.is_empty then
 323                                 write "\t: Root"
 324                         else for s in [c.supers.first] do
 325                                 write "\t: {s}<E>"
 326                         end
 327                         if interfaces then
 328                                 write "\{\}"
 329                                 if c.supers.is_empty then
 330                                         write "class X{c}<E>: XRoot, {c}<E>"
 331                                 else
 332                                         write "class X{c}<E>: X{c.supers.first}<E>, {c}<E>"
 333                                 end
 334                         end
 335                         write "\{"
 336                         write "\toverride public long Id() \{ return {c.id}; \}"
 337                         write "\tvirtual public long F{c.id}() \{ return {c.id}; \}"
 338                         write "\tpublic long A{c.id} = {c.id};"
 339                         write "\tpublic {cname}() \{ aid = {c.id}; \}"
 340                         write "\}"
 341                 end
 342
 343                 write "static void Main(string[] args) \{"
 344                 write "\tRoot b = {ia.first};"
 345                 write "\tRoot tmp = b;"
 346                 for i in ia do
 347                         write "\tb = b.SetNext({i});"
 348                 end
 349                 write "\tb.SetNext(tmp);"
 350                 write "\tRoot a = {ia.last};"
 351                 write "\ttmp = a;"
 352                 for i in [1..poly[ do
 353                         write "\ta = a.SetNext({ia[ia.length - 1 - i]});"
 354                 end
 355                 write "\ta.SetNext(tmp);"
 356                 write "\tTest(b, b.GetNext(), 10, -100);"
 357                 write "\tTest(a, a.GetNext(), {loops}, 0);"
 358                 write "\}"
 359
 360                 write "static void Test(Root a, Root b, long loops, long start) \{"
 361                 write "\tlong x = start;"
 362                 write "\tfor(long i = loops; i > 0; i--) \{"
 363                 write "\t\tfor(long j = loops; j >0; j--) \{"
 364                 var test = "x>=0"
 365                 if not dry then test = testcsharp(interfaces)
 366                 write "\t\t\tif({test}) \{"
 367                 write "\t\t\t\tRoot tmp = a; a = b; b = tmp;"
 368                 if check then write "\t\t\t\tx++;"
 369                 write "\t\t\t\} else \{ x += 1; a = a.GetNext(); b = b.GetNext();\};"
 370                 write "\t\t\}"
 371                 write "\t\tx += 1; a = a.GetNext(); b = b.GetNext();"
 372                 write "\t\}"
 373                 write "\tSystem.Console.WriteLine(x);"
 374                 write "\}"
 375                 write "\}"
 376                 file.close
 377         end
 378
 379         fun initscala(res: Array[String], interfaces: Bool) do return
 380         fun testscala(interfaces: Bool): String do return "true"
 381         fun writescala(dir: String, name: String, interfaces: Bool)
 382         do
 383                 var ia = new Array[String]
 384                 initscala(ia, interfaces)
 385                 if ia.is_empty then
 386                         print "Scala disabled"
 387                         return
 388                 end
 389
 390                 dir = "{dir}/scala"
 391                 dir.mkdir
 392                 file = new FileWriter.open("{dir}/{name}.scala")
 393
 394                 write "object {name} \{"
 395                 if use_root0 then
 396                         write "class Root0 \{"
 397                 else
 398                         write "class Root \{"
 399                 end
 400                 write "\tdef id: Long = 0; var aid: Long = id; var next: Root = null; def getNext: Root = next; def setNext(next: Root): Root = \{ this.next = next; return next; \} \}"
 401
 402                 if use_root0 then
 403                         write "class Root extends Root0 \{\}"
 404                 end
 405
 406                 for c in classes do
 407                         if interfaces then
 408                                 write "trait {c}[+E] "
 409                         else
 410                                 write "class {c}[+E] "
 411                         end
 412                         if c.supers.is_empty then
 413                                 write "\textends Root"
 414                         else for s in [c.supers.first] do
 415                                 write "\textends {s}[E]"
 416                         end
 417                         if interfaces then
 418                                 write "\{\}"
 419                                 if c.supers.is_empty then
 420                                         write "class X{c}[E] extends {c}[E]"
 421                                 else
 422                                         write "class X{c}[E] extends X{c.supers.first}[E] with {c}[E]"
 423                                 end
 424                         end
 425                         write "\{"
 426                         write "\toverride def id: Long = {c.id}"
 427                         write "\tdef f{c.id}: Long = {c.id}"
 428                         if interfaces then
 429                                 write "\tvar a{c.id}: Long = {c.id}"
 430                         end
 431                         write "\}"
 432                 end
 433
 434                 write "def main(args: Array[String]) = \{"
 435                 write "\tvar b: Root = {ia.first};"
 436                 write "\tvar tmp = b;"
 437                 for i in ia do
 438                         write "\tb = b.setNext({i});"
 439                 end
 440                 write "\tb.setNext(tmp);"
 441                 write "\tvar a: Root = {ia.last};"
 442                 write "\ttmp = a;"
 443                 for i in [1..poly[ do
 444                         write "\ta = a.setNext({ia[ia.length - 1 - i]});"
 445                 end
 446                 write "\ta.setNext(tmp);"
 447                 write "\ttest(b, b.getNext, 10, -100);"
 448                 write "\ttest(a, a.getNext, {loops}, 0);"
 449                 write "\}"
 450
 451                 write "def test(aa:Root, bb:Root, l: Long, start: Long) = \{"
 452                 write "\tvar a = aa"
 453                 write "\tvar b = bb"
 454                 write "\tvar x = start"
 455                 write "\tvar loops = l"
 456                 write "\tvar i = loops"
 457                 write "\twhile (i > 0) \{"
 458                 write "\t\tvar j = loops"
 459                 write "\t\twhile (j > 0) \{"
 460                 var test = "x>=0"
 461                 if not dry then test = testscala(interfaces)
 462                 write "\t\t\tif ({test}) \{"
 463                 write "\t\t\t\tval tmp = a; a = b; b = tmp;"
 464                 if check then write "\t\t\t\tx += 1;"
 465                 write "\t\t\t\} else \{ x += 1; a = a.getNext; b = b.getNext;\}"
 466                 write "\t\t\tj -= 1"
 467                 write "\t\t\}"
 468                 write "\t\tx += 1; a = a.getNext; b = b.getNext;"
 469                 write "\t\ti -= 1"
 470                 write "\t\t\}"
 471                 write "\tprintln(x)"
 472                 write "\}"
 473                 write "\}"
 474
 475                 file.close
 476         end
 477
 478         fun initcpp(res: Array[String]) do return
 479         fun testcpp: String do return "true"
 480         fun writecpp(dir: String, name: String)
 481         do
 482                 var ia = new Array[String]
 483                 initcpp(ia)
 484                 if ia.is_empty then
 485                         print "C++ diabled"
 486                         return
 487                 end
 488
 489                 dir = "{dir}/cpp"
 490                 dir.mkdir
 491                 file = new FileWriter.open("{dir}/{name}.cpp")
 492
 493                 write "#include <iostream>"
 494                 write "#include <stdlib.h>"
 495                 if use_root0 then
 496                         write "class Root;"
 497                         write "class Root0"
 498                 else
 499                         write "class Root"
 500                 end
 501                 write "\t\{ public: virtual long id() \{ return 0;\} long aid; Root *next; virtual Root *setNext(Root *n) \{this->next = n; return n;\} \};"
 502
 503                 if use_root0 then
 504                         write "class Root: public virtual Root0 \{\};"
 505                 end
 506
 507                 for c in classes do
 508                         write "template<class E>"
 509                         write "class {c} "
 510                         if c.supers.is_empty then
 511                                 write "\t: public virtual Root"
 512                         else for s in [c.supers.first] do
 513                                 write "\t: public virtual {s}<E>"
 514                         end
 515                         write "\{"
 516                         write "\tpublic: virtual long id() \{ return {c.id}; \}"
 517                         write "\tvirtual long f{c.id}() \{ return {c.id}; \}"
 518                         write "\tlong a{c.id};"
 519                         write "\t{c}(): a{c.id}({c.id}) \{ this->aid = {c.id}; \}"
 520                         write "\};"
 521                 end
 522
 523                 write "void test(Root *a, Root *b, long loops, long start) \{"
 524                 write "\tlong x = start;"
 525                 write "\tfor(long i = loops; i > 0; i--) \{"
 526                 write "\t\tfor(int j = loops; j > 0; j--) \{"
 527                 var test = "x>=0"
 528                 if not dry then test = testcpp
 529                 write "\t\t\tif({test}) \{"
 530                 write "\t\t\t\tRoot *tmp = a; a = b; b = tmp;"
 531                 if check then write "\t\t\t\tx += 1;"
 532                 write "\t\t\t\} else \{ x++; a = a->next; b = b->next;\}"
 533                 write "\t\t\}"
 534                 write "\t\tx++; a = a->next; b = b->next;"
 535                 write "\t\}"
 536                 write "\tstd::cout << x << std::endl;"
 537                 write "\}"
 538
 539                 write "int main(int argc, char **argv) \{"
 540                 write "\tRoot *b = {ia.first};"
 541                 write "\tRoot *tmp = b;"
 542                 for i in ia do
 543                         write "\tb = b->setNext({i});"
 544                 end
 545                 write "\tb->setNext(tmp);"
 546                 write "\tRoot *a = {ia.last};"
 547                 write "\ttmp = a;"
 548                 for i in [1..poly[ do
 549                         write "\ta = a->setNext({ia[ia.length - 1 - i]});"
 550                 end
 551                 write "\ta->setNext(tmp);"
 552                 write "\ttest(b, b->next, 10, -100);"
 553                 write "\ttest(a, a->next, {loops}, 0);"
 554                 write "\}"
 555
 556                 file.close
 557         end
 558
 559         fun inite(res: Array[String], se: Bool) do return
 560         fun teste(se: Bool): String do return "true"
 561         fun locale(se: Bool) do end
 562         fun writee(dir: String, name: String, se: Bool)
 563         do
 564                 var ia = new Array[String]
 565                 inite(ia,se)
 566                 if ia.is_empty then
 567                         print "Eiffel disabled"
 568                         return
 569                 end
 570
 571                 if se then
 572                         dir = "{dir}/se/{name}"
 573                 else
 574                         dir = "{dir}/es/{name}"
 575                 end
 576                 dir.mkdir
 577
 578                 var root0
 579                 if use_root0 then
 580                         root0 = "ROOT0"
 581                         file = new FileWriter.open("{dir}/root0.e")
 582                 else
 583                         root0 = "ROOT"
 584                         file = new FileWriter.open("{dir}/root.e")
 585                 end
 586
 587                 var istk = ""
 588                 if se then istk = " is"
 589                 write "class {root0}"
 590                 write "feature id: INTEGER_64 {istk} do Result := 0 end"
 591                 write "aid: INTEGER_64"
 592                 write "xnext: detachable ROOT"
 593                 write "next: ROOT do check attached xnext as n then Result := n end end"
 594                 write "set_next(n: ROOT): ROOT do xnext := n Result := n end"
 595                 write "make do aid := id end"
 596                 write "end"
 597                 file.close
 598
 599                 if use_root0 then
 600                         file = new FileWriter.open("{dir}/root.e")
 601                         write "class ROOT inherit ROOT0 end "
 602                         file.close
 603                 end
 604
 605                 for c in classes do
 606                         file = new FileWriter.open("{dir}/{c}.e")
 607                         write "class {c}[E] "
 608                         if c.supers.is_empty then
 609                                 write "\tinherit ROOT"
 610                         else for s in [c.supers.first] do
 611                                 write "\tinherit {s}[E]"
 612                         end
 613                         write "\t\tredefine id, make end"
 614                         write "create make"
 615                         write "feature"
 616                         write "\tid: INTEGER_64 {istk} do Result := {c.id} end"
 617                         write "\tf{c.id}: INTEGER_64 {istk} do Result := {c.id} end"
 618                         write "\ta{c.id}: INTEGER_64 {istk} attribute Result := {c.id} end"
 619                         write "make do aid := {c.id} end"
 620                         write "end"
 621                         file.close
 622                 end
 623
 624                 file = new FileWriter.open("{dir}/app{name}.e")
 625                 write "class APP{name.to_upper}"
 626                 if se then
 627                         write "insert ARGUMENTS"
 628                 end
 629                 write "create make"
 630                 write "feature"
 631
 632                 if se then
 633                         write "\tmake{istk}"
 634                 else
 635                         write "\tmake(args: ARRAY[STRING]){istk}"
 636                 end
 637                 write "\t\tlocal"
 638                 write "\t\t\ta: ROOT"
 639                 write "\t\t\tb: ROOT"
 640                 write "\t\t\ttmp: ROOT"
 641                 write "\t\tdo"
 642                 write "\t\t\tb := {ia.first} .make"
 643                 write "\t\t\ttmp := b"
 644                 for i in ia do
 645                         write "\t\t\tb := b.set_next({i} .make)"
 646                 end
 647                 write "\t\t\ttmp := b.set_next(tmp)"
 648
 649                 write "\t\t\ta := {ia.last} .make"
 650                 write "\t\t\ttmp := a"
 651                 for i in [1..poly[ do
 652                         write "\t\t\ta := a.set_next({ia[ia.length - 1 - i]} .make)"
 653                 end
 654                 write "\t\t\ttmp := a.set_next(tmp);"
 655                 write "\t\t\ttest(b, b.next, 10, -100)"
 656                 write "\t\t\ttest(a, a.next, {loops}, 0)"
 657                 write "\t\tend"
 658
 659                 write "\ttest(aa: ROOT; bb: ROOT; l: INTEGER_64; start: INTEGER_64){istk}"
 660                 write "\t\tlocal"
 661                 write "\t\t\ta: ROOT"
 662                 write "\t\t\tb: ROOT"
 663                 write "\t\t\ttmp: ROOT"
 664                 write "\t\t\ti: INTEGER_64"
 665                 write "\t\t\tj: INTEGER_64"
 666                 write "\t\t\tx: INTEGER_64"
 667                 locale(se)
 668                 write "\t\t\tloops: INTEGER_64"
 669                 write "\t\tdo"
 670                 write "\t\t\ta := aa"
 671                 write "\t\t\tb := bb"
 672                 write "\t\t\tx := start"
 673                 write "\t\t\tloops := l"
 674                 write "\t\t\tfrom i := loops until i<=0 loop"
 675                 write "\t\t\t\tfrom j := loops until j<=0 loop"
 676                 var test = "x >= 0"
 677                 if not dry then test = teste(se)
 678                 write "\t\t\t\t\tif {test} then"
 679                 write "\t\t\t\t\t\ttmp := a; a := b; b := tmp"
 680                 if check then write "\t\t\t\t\tx := x + 1"
 681                 write "\t\t\t\t\telse x := x + 1; a := a.next; b := b.next end"
 682                 write "\t\t\t\t\tj := j - 1"
 683                 write "\t\t\t\tend"
 684                 write "\t\t\t\tx := x + 1; a := a.next; b := b.next"
 685                 write "\t\t\t\ti := i - 1"
 686                 write "\t\t\tend"
 687                 write "\t\t\tprint(x.out)"
 688                 write "\t\t\tprint(\"%N\")"
 689                 write "\t\tend"
 690                 write "end"
 691                 file.close
 692         end
 693
 694         fun initpython(res: Array[String]) do return
 695         fun testpython: String do return "true"
 696         fun writepython(dir: String, name: String)
 697         do
 698                 var ia = new Array[String]
 699                 initpython(ia)
 700                 if ia.is_empty then
 701                         print "Python disabled"
 702                         return
 703                 end
 704
 705                 dir = "{dir}/python"
 706                 dir.mkdir
 707                 file = new FileWriter.open("{dir}/{name}.py")
 708
 709                 if use_root0 then
 710                         write "class Root0(object):"
 711                 else
 712                         write "class Root(object):"
 713                 end
 714                 write "\tdef id(self): return 0"
 715                 write "\tdef set_next(self, n):\n\t\tself.next = n\n\t\treturn n"
 716                 write "\tdef __init__(self): self.aid = self.id()"
 717
 718                 if use_root0 then
 719                         write "class Root(Root0): pass"
 720                 end
 721
 722                 for c in classes do
 723                         if c.supers.is_empty then
 724                                 write "class {c}(Root):"
 725                         else
 726                                 write "class {c}({c.supers.join(",")}):"
 727                         end
 728                         write "\tdef id(self): return {c.id}"
 729                         write "\tdef f{c.id}(self): return {c.id}"
 730                         write "\tdef __init__(self):"
 731                         write "\t\tsuper({c}, self).__init__()"
 732                         write "\t\ta{c.id} = {c.id}"
 733                 end
 734
 735                 write "def test(a, b, loops, start):"
 736                 write "\tx = start"
 737                 write "\ti = loops"
 738                 write "\twhile i > 0:"
 739                 write "\t\tj = loops"
 740                 write "\t\twhile j > 0:"
 741                 var test = "x >= 0"
 742                 if not dry then test = testpython
 743                 write "\t\t\tif {test}:"
 744                 write "\t\t\t\ttmp = a; a = b; b = tmp"
 745                 if check then write "\t\t\t\tx += 1"
 746                 write "\t\t\telse:"
 747                 write "\t\t\t\tx = x + 1; a = a.next; b = b.next"
 748                 write "\t\t\tj -= 1"
 749                 write "\t\tx = x + 1; a = a.next; b = b.next"
 750                 write "\t\ti -= 1"
 751                 write "\tprint(x)"
 752
 753                 write "b = {ia.first}"
 754                 write "tmp = b"
 755                 for i in ia do
 756                         write "b = b.set_next({i})"
 757                 end
 758                 write "b.next = tmp"
 759                 write "a = {ia.last}"
 760                 write "tmp = a"
 761                 for i in [1..poly[ do
 762                         write "a = a.set_next({ia[ia.length - 1 - i]})"
 763                 end
 764                 write "a.next = tmp"
 765                 write "test(b, b.next, 10, -100)"
 766                 write "test(a, a.next, {loops}, 0)"
 767
 768                 file.close
 769         end
 770
 771         var count = false
 772
 773         fun genall
 774         do
 775                 var g = self
 776                 var outdir = args.first
 777                 var name = args[1]
 778                 var use_interfaces = self.use_interfaces
 779                 if args.length > 2 then g.dept = args[2].to_i
 780                 if args.length > 3 then loops = args[3].to_i
 781                 if args.length > 4 then use_interfaces = false
 782
 783                 g.genhier
 784
 785                 g.writenit(outdir, name)
 786                 g.writejava(outdir, name, use_interfaces)
 787                 g.writecsharp(outdir, name, use_interfaces)
 788                 g.writescala(outdir, name, use_interfaces)
 789                 g.writecpp(outdir, name)
 790                 g.writee(outdir, "{name}_se", true)
 791                 g.writee(outdir, name, false)
 792                 g.writepython(outdir, name)
 793         end
 794 end
 795
 796 var g = new Generator
 797 g.genall