src/benchs/gen.nit

   1 #!/usr/bin/env nit
   2
   3 # Microbenchmak generation for multiple language
   4 # Just a quick an dirty Nit script file :)
   5
   6 class Klass
   7         var id: Int
   8         var supers = new Array[Klass]
   9         var all_supers = new HashSet[Klass]
  10         redef fun to_s
  11         do
  12                 return "C{id}"
  13         end
  14 end
  15
  16
  17 class Generator
  18         var classes = new Array[Klass]
  19
  20         var width = 5
  21         var height = 5
  22         var superprobs: Array[Int] = [40, 20, 5]
  23
  24         fun genhier
  25         do
  26                 var i = 0
  27                 for w in [0..width[ do
  28                         var s: nullable Klass = null
  29                         for h in [0..height[ do
  30                                 i += 1
  31                                 var c = new Klass(i)
  32
  33                                 classes.add(c)
  34                                 c.all_supers.add(c)
  35                                 if s != null then
  36                                         c.supers.add(s)
  37                                         c.all_supers.add_all(s.all_supers)
  38                                 end
  39                                 s = c
  40                         end
  41                 end
  42
  43                 for j in [0..listlen[ do
  44                         var c = classes[classes.length - 1 - (j % classes.length)]
  45                         list.unshift(c)
  46                         unlist.push(c)
  47                 end
  48         end
  49
  50         # List of instantited class in the order to read
  51         var list = new List[Klass]
  52
  53         # List of instantited class in the order to push
  54         var unlist = new List[Klass]
  55
  56         var arraylen = 2000
  57         var loops = 10000
  58
  59         var listlen = 50
  60
  61         var file: nullable OFStream = null
  62         fun write(str: String)
  63         do
  64                 file.write(str)
  65                 file.write("\n")
  66         end
  67
  68         fun writenit(name: String)
  69         do
  70                 file = new OFStream.open("{name}.nit")
  71                 write "class Root\n\tfun id: Int do return 0\nend"
  72                 for c in classes do
  73                         write "class {c}"
  74                         if c.supers.is_empty then
  75                                 write "\tsuper Root"
  76                         else for s in c.supers do
  77                                 write "\tsuper {s}"
  78                         end
  79                         write "\tredef fun id do return {c.id}"
  80                         write "end"
  81                 end
  82                 write "class L[E]\n\tsuper Root\n\tvar item:E \n\tvar next: nullable L[E]\ninit(item:E,next: nullable L[E])do\n\tself.item = item\n\tself.next=next\nend\nend"
  83
  84                 write "fun fill: nullable L[Root]\ndo"
  85                 write "\tvar head: nullable L[Root] = null"
  86                 write "\tvar l: L[Root]"
  87                 for c in classes do
  88                         write "\tvar l{c} = new L[{c}](new {c}, null)"
  89                         write "\thead = new L[Root](l{c}, head)"
  90                 end
  91                 write "\thead = null"
  92                 write "for x in [0..{arraylen}[ do"
  93                 for i in [0..listlen[ do
  94                         var c = unlist[i]
  95                         write "\tvar l{i} = new L[{c}](new {c}, null)"
  96                         write "\thead = new L[Root](l{i}, head)"
  97                 end
  98                 write "end"
  99                 write "return head"
 100                 write "end"
 101
 102                 write "fun run(head1: nullable L[Root], head2: nullable L[Root]): Int\ndo"
 103                 write "\tvar cpt = 0"
 104                 write "\tvar y = {loops/list.length}"
 105                 write "\twhile y > 0 do"
 106                 write "\tvar n1 = head1"
 107                 write "\tvar n2 = head2"
 108                 write "\twhile not n1 is null do"
 109                 for i in [0..listlen[ do
 110                         var c = list[i]
 111                         write "\t\tvar l{i} = n1.item"
 112                         write "\t\tvar lc{i} = l{i}.as(L[{c}])"
 113                         write "\t\tvar c{i} = lc{i}.item"
 114                         write "\t\tn1 = n1.next"
 115                         if count then
 116                                 write "\t\tif c{i}.id == {c.id} then cpt += 1"
 117                         end
 118                         write "\t\tvar l2_{i} = n2.item"
 119                         write "\t\tvar lc2_{i} = l2_{i}.as(L[{c}])"
 120                         write "\t\tlc2_{i}.item = c{i}"
 121                         write "\t\tn2 = n2.next"
 122                 end
 123                 write "\tend"
 124                 write "y -= 1"
 125                 write "end"
 126                 write "return cpt"
 127                 write "end"
 128
 129                 write "var head = fill"
 130                 write "var loops = 25"
 131                 write "if not args.is_empty then loops = args.first.to_i "
 132                 write "for x in [0..loops[ do"
 133                 write "\tvar cpt = run(head, head)"
 134                 write "\tprint \"\{x\}:\tcpt:\{cpt\}\""
 135                 write "end"
 136                 file.close
 137         end
 138
 139         fun writejava(name: String, interfaces: Bool)
 140         do
 141                 var cl = ""
 142                 if interfaces then cl = "X"
 143                 file = new OFStream.open("{name}.java")
 144                 write "class {name} \{"
 145                 if interfaces then
 146                         write "static interface Root\n\t\{ int id(); \}"
 147                 else
 148                         write "static class Root\n\t\{ int id() \{ return 0;\} \}"
 149                 end
 150                 for c in classes do
 151                         if interfaces then
 152                                 write "static interface {c} "
 153                         else
 154                                 write "static class {c} "
 155                         end
 156                         if c.supers.is_empty then
 157                                 write "\textends Root"
 158                         else for s in [c.supers.first] do
 159                                 write "\textends {s}"
 160                         end
 161                         if interfaces then
 162                                 write "\{\}"
 163                                 write "static class X{c} implements {c}"
 164                         end
 165                         write "\{"
 166                         write "\tpublic int id() \{ return {c.id}; \}"
 167                         write "\}"
 168                 end
 169                 write "static class L<E>"
 170                 if interfaces then
 171                         write "implements Root \{"
 172                 else
 173                         write "extends Root \{"
 174                 end
 175                 write "\tE _item; E item() \{ return _item; \} void set_item(E i) \{ _item = i; \}"
 176                 write "\tL<E> _next; L<E> next() \{ return _next; \} void set_next(L<E> n) \{ _next = n; \}"
 177                 write "\tL(E i, L<E> n) \{ set_item(i); set_next(n); \}"
 178                 write "\tpublic int id() \{ return -1; \}"
 179                 write "\}"
 180
 181                 write "static L<Root> fill() \{"
 182                 write "\tL<Root> head = null;"
 183                 for c in classes do
 184                         write "\tL<{c}> l{c} = new L<{c}>(new {cl}{c}(), null);"
 185                         write "\thead = new L<Root>(l{c}, head);"
 186                 end
 187                 write "\thead = null;"
 188                 write "for (int x=0; x<{arraylen}; x++) \{"
 189                 for i in [0..listlen[ do
 190                         var c = unlist[i]
 191                         write "\tL<{c}> l{i} = new L<{c}>(new {cl}{c}(), null);"
 192                         write "\thead = new L<Root>(l{i}, head);"
 193                 end
 194                 write "\}"
 195                 write "return head;"
 196                 write "\}"
 197
 198                 write "static int run(L<Root> head1, L<Root> head2) \{"
 199                 write "\tint cpt = 0;"
 200                 write "\tint y = {loops/list.length};"
 201                 write "\twhile (y > 0) \{;"
 202                 write "\tL<Root> n1 = head1;"
 203                 write "\tL<Root> n2 = head2;"
 204                 write "\twhile (n1 != null) \{"
 205                 for i in [0..listlen[ do
 206                         var c = list[i]
 207                         write "\t\tRoot l{i} = n1.item();"
 208                         write "\t\tL<{c}> lc{i} = (L<{c}>)l{i};"
 209                         write "\t\t{c} c{i} = lc{i}.item();"
 210                         write "\t\tn1 = n1.next();"
 211                         if count then
 212                                 write "\t\tif (c{i}.id() == {c.id}) cpt += 1;"
 213                         end
 214                         write "\t\tRoot l2_{i} = n2.item();"
 215                         write "\t\tL<{c}> lc2_{i} = (L<{c}>)l2_{i};"
 216                         write "\t\tlc2_{i}.set_item(c{i});"
 217                         write "\t\tn2 = n2.next();"
 218                 end
 219                 write "\t\}"
 220                 write "y -= 1;"
 221                 write "\}"
 222                 write "return cpt;"
 223                 write "\}"
 224
 225                 write "static public void main(String args[]) \{"
 226                 write "L<Root> head = fill();"
 227                 write "int loops = 25;"
 228                 write "if (args.length > 0) loops = Integer.parseInt(args[0]);"
 229                 write "for (int x=0; x<loops; x++) \{"
 230                 write "\tint cpt = run(head, head);"
 231                 write "\tSystem.out.println(\"\" + x + \":\\t\" + cpt);"
 232                 write "\}"
 233                 write "\}"
 234                 write "\}"
 235                 file.close
 236         end
 237
 238         fun writecsharp(name: String, interfaces: Bool)
 239         do
 240                 var cl = ""
 241                 if interfaces then cl = "X"
 242                 file = new OFStream.open("{name}.cs")
 243                 write "class {name} \{"
 244                 if interfaces then
 245                         write "interface Root\n\t\{ int Id(); \}"
 246                 else
 247                         write "class Root\n\t\{ public int Id() \{ return 0;\} \}"
 248                 end
 249                 for c in classes do
 250                         if interfaces then
 251                                 write "interface {c} "
 252                         else
 253                                 write "class {c} "
 254                         end
 255                         if c.supers.is_empty then
 256                                 write "\t: Root"
 257                         else for s in [c.supers.first] do
 258                                 write "\t: {s}"
 259                         end
 260                         if interfaces then
 261                                 write "\{\}"
 262                                 write "class X{c} : {c}"
 263                         end
 264                         write "\{"
 265                         write "\tpublic int Id() \{ return {c.id}; \}"
 266                         write "\}"
 267                 end
 268                 write "class L<E>"
 269                 if interfaces then
 270                         write ": Root \{"
 271                 else
 272                         write ": Root \{"
 273                 end
 274                 write "\tE _item;"
 275                 write "\tpublic E Item() \{ return _item; \}"
 276                 write "\tpublic void SetItem(E i) \{ _item = i; \}"
 277                 write "\tL<E> _next;"
 278                 write "\tpublic L<E> Next() \{ return _next; \}"
 279                 write "\tpublic void SetNext(L<E> n) \{ _next = n; \}"
 280                 write "\tpublic L(E i, L<E> n) \{ SetItem(i); SetNext(n); \}"
 281                 write "\tpublic int Id() \{ return -1; \}"
 282                 write "\}"
 283
 284                 write "static L<Root> Fill() \{"
 285                 write "\tL<Root> head = null;"
 286                 for c in classes do
 287                         write "\tL<{c}> l{c} = new L<{c}>(new {cl}{c}(), null);"
 288                         write "\thead = new L<Root>(l{c}, head);"
 289                 end
 290                 write "\thead = null;"
 291                 write "for (int x=0; x<{arraylen}; x++) \{"
 292                 for i in [0..listlen[ do
 293                         var c = unlist[i]
 294                         write "\tL<{c}> l{i} = new L<{c}>(new {cl}{c}(), null);"
 295                         write "\thead = new L<Root>(l{i}, head);"
 296                 end
 297                 write "\}"
 298                 write "return head;"
 299                 write "\}"
 300
 301                 write "static int Run(L<Root> head1, L<Root> head2) \{"
 302                 write "\tint cpt = 0;"
 303                 write "\tint y = {loops/list.length};"
 304                 write "\twhile (y > 0) \{;"
 305                 write "\tL<Root> n1 = head1;"
 306                 write "\tL<Root> n2 = head2;"
 307                 write "\twhile (n1 != null) \{"
 308                 for i in [0..listlen[ do
 309                         var c = list[i]
 310                         write "\t\tRoot l{i} = n1.Item();"
 311                         write "\t\tL<{c}> lc{i} = (L<{c}>)l{i};"
 312                         write "\t\t{c} c{i} = lc{i}.Item();"
 313                         write "\t\tn1 = n1.Next();"
 314                         if count then
 315                                 write "\t\tif (c{i}.Id() == {c.id}) cpt += 1;"
 316                         end
 317                         write "\t\tRoot l2_{i} = n2.Item();"
 318                         write "\t\tL<{c}> lc2_{i} = (L<{c}>)l2_{i};"
 319                         write "\t\tlc2_{i}.SetItem(c{i});"
 320                         write "\t\tn2 = n2.Next();"
 321                 end
 322                 write "\t\}"
 323                 write "y -= 1;"
 324                 write "\}"
 325                 write "return cpt;"
 326                 write "\}"
 327
 328                 write "static void Main(string[] args) \{"
 329                 write "L<Root> head = Fill();"
 330                 write "int loops = 25;"
 331                 write "if (args.Length > 0) loops = int.Parse(args[0]);"
 332                 write "for (int x=0; x<loops; x++) \{"
 333                 write "\tint cpt = Run(head, head);"
 334                 write "\tSystem.Console.WriteLine(\"\" + x + \":\\t\" + cpt);"
 335                 write "\}"
 336                 write "\}"
 337                 write "\}"
 338                 file.close
 339         end
 340
 341         fun writescala(name: String)
 342         do
 343                 var cl = ""
 344                 file = new OFStream.open("{name}.scala")
 345                 write "object {name} \{"
 346                 write "class Root\n\t\{ def id: Int = 0 \}"
 347                 for c in classes do
 348                         write "class {c} "
 349                         if c.supers.is_empty then
 350                                 write "\textends Root"
 351                         else for s in [c.supers.first] do
 352                                 write "\textends {s}"
 353                         end
 354                         write "\{"
 355                         write "\toverride def id: Int = {c.id}"
 356                         write "\}"
 357                 end
 358                 write "class L[E](var _item: E, var _next: L[E]) extends Root \{"
 359                 write "\tdef item: E = _item"
 360                 write "\tdef set_item(i: E) = this._item = i"
 361                 write "\tdef next: L[E] = _next"
 362                 write "\tdef set_next(n: L[E]) = this._next = n"
 363                 write "\toverride def id: Int = -1"
 364                 write "\}"
 365
 366                 write "def fill: L[Root] = \{"
 367                 write "\tvar head: L[Root] = null"
 368                 for c in classes do
 369                         write "\tvar l{c}: L[{c}] = new L[{c}](new {cl}{c}(), null)"
 370                         write "\thead = new L[Root](l{c}, head)"
 371                 end
 372                 write "\thead = null"
 373                 write "\tfor (x <- 0 to {arraylen}) \{"
 374                 for i in [0..listlen[ do
 375                         var c = unlist[i]
 376                         write "\t\tvar l{i}: L[{c}] = new L[{c}](new {cl}{c}(), null)"
 377                         write "\t\thead = new L[Root](l{i}, head)"
 378                 end
 379                 write "\t\}"
 380                 write "\treturn head"
 381                 write "\}"
 382
 383                 write "def run(head1: L[Root], head2: L[Root]): Int = \{"
 384                 write "\tvar cpt: Int = 0"
 385                 write "\tvar y: Int = {loops/list.length}"
 386                 write "\twhile (y > 0) \{"
 387                 write "\tvar n1: L[Root] = head1"
 388                 write "\tvar n2: L[Root] = head2"
 389                 write "\twhile (n1 != null) \{"
 390                 for i in [0..listlen[ do
 391                         var c = list[i]
 392                         write "\t\tvar l{i}: Root = n1.item"
 393                         write "\t\tvar lc{i}: L[{c}] = l{i}.asInstanceOf[L[{c}]]"
 394                         write "\t\tvar c{i}: {c} = lc{i}.item"
 395                         write "\t\tn1 = n1.next"
 396                         if count then
 397                                 write "\t\tif (c{i}.id == {c.id}) cpt += 1"
 398                         end
 399                         write "\t\tvar l2_{i}: Root = n2.item"
 400                         write "\t\tvar lc2_{i}: L[{c}] = l2_{i}.asInstanceOf[L[{c}]]"
 401                         write "\t\tlc2_{i}.set_item(c{i})"
 402                         write "\t\tn2 = n2.next"
 403                 end
 404                 write "\t\}"
 405                 write "y -= 1"
 406                 write "\}"
 407                 write "return cpt"
 408                 write "\}"
 409
 410                 write "def main(args: Array[String]) = \{"
 411                 write "\tvar head: L[Root] = fill"
 412                 write "\tvar loops: Int = 25"
 413                 write "\tif (args.length > 0) \{"
 414                 write "\t\tloops = Integer.parseInt(args(0))"
 415                 write "\t\}"
 416                 write "\tfor (x <- 0 to loops) \{"
 417                 write "\t\tvar cpt: Int = run(head, head)"
 418                 write "\t\tprintln(\"\" + x + \":\\t\" + cpt)"
 419                 write "\t\}"
 420                 write "\}"
 421                 write "\}"
 422                 file.close
 423         end
 424
 425         fun writecpp(name: String)
 426         do
 427                 file = new OFStream.open("{name}.cpp")
 428                 write "#include <iostream>"
 429                 write "#include <stdlib.h>"
 430                 write "class Root\n\t\{ public: virtual int id() \{ return 0;\} \};"
 431                 for c in classes do
 432                         write "class {c} "
 433                         if c.supers.is_empty then
 434                                 write "\t: public virtual Root"
 435                         else for s in [c.supers.first] do
 436                                 write "\t: public virtual {s}"
 437                         end
 438                         write "\{"
 439                         write "\tpublic: virtual int id() \{ return {c.id}; \}"
 440                         write "\};"
 441                 end
 442                 write "template<class E>"
 443                 write "class L: public virtual Root \{ public:"
 444                 write "\tE _item; virtual E item() \{ return _item; \} virtual void set_item(E i) \{ _item = i; \}"
 445                 write "\tL<E> *_next; virtual L<E> *next() \{ return _next; \} virtual void set_next(L<E> *n) \{ _next = n; \}"
 446                 write "\tL(E i, L<E> *n) \{ set_item(i); set_next(n); \}"
 447                 write "\};"
 448
 449                 write "L<Root*> *fill() \{"
 450                 write "\tL<Root*> *head = 0;"
 451                 for c in classes do
 452                         write "\tL<{c}*> *l{c} = new L<{c}*>(new {c}(), 0);"
 453                         write "\thead = new L<Root*>(l{c}, head);"
 454                 end
 455                 write "\thead = 0;"
 456                 write "for (int x=0; x<{arraylen}; x++) \{"
 457                 for i in [0..listlen[ do
 458                         var c = unlist[i]
 459                         write "\tL<{c}*> *l{i} = new L<{c}*>(new {c}(), 0);"
 460                         write "\thead = new L<Root*>(l{i}, head);"
 461                 end
 462                 write "\}"
 463                 write "return head;"
 464                 write "\}"
 465
 466                 write "int run(L<Root*> *head1, L<Root*> *head2) \{"
 467                 write "\tint cpt = 0;"
 468                 write "\tint y = {loops/list.length};"
 469                 write "\twhile (y > 0) \{;"
 470                 write "\tL<Root*> *n1 = head1;"
 471                 write "\tL<Root*> *n2 = head2;"
 472                 write "\twhile (n1 != 0) \{"
 473                 for i in [0..listlen[ do
 474                         var c = list[i]
 475                         write "\t\tRoot *l{i} = n1->item();"
 476                         write "\t\tL<{c}*> *lc{i} = dynamic_cast<L<{c}*>*>(l{i});"
 477                         write "\t\t{c} *c{i} = lc{i}->item();"
 478                         write "\t\tn1 = n1->next();"
 479                         if count then
 480                                 write "\t\tif (c{i}->id() == {c.id}) cpt += 1;"
 481                         end
 482                         write "\t\tRoot *l2_{i} = n2->item();"
 483                         write "\t\tL<{c}*> *lc2_{i} = dynamic_cast<L<{c}*>*>(l2_{i});"
 484                         write "\t\tlc2_{i}->set_item(c{i});"
 485                         write "\t\tn2 = n2->next();"
 486                 end
 487                 write "\t\}"
 488                 write "y -= 1;"
 489                 write "\}"
 490                 write "return cpt;"
 491                 write "\}"
 492
 493                 write "int main(int argc, char **argv) \{"
 494                 write "L<Root*> *head = fill();"
 495                 write "int loops = 25;"
 496                 write "if (argc > 1) loops = atoi(argv[1]);"
 497                 write "for (int x=0; x<loops; x++) \{"
 498                 write "\tint cpt = run(head, head);"
 499                 write "\tstd::cout << x << \":\\t\" << cpt << std::endl;"
 500                 write "\}"
 501                 write "\treturn 0;"
 502                 write "\}"
 503                 file.close
 504         end
 505         fun writee(name: String, se: Bool)
 506         do
 507                 var istk = ""
 508                 if se then istk = " is"
 509
 510                 name.mkdir
 511                 file = new OFStream.open("{name}/root.e")
 512                 write "class ROOT"
 513                 write "feature id: INTEGER {istk} do Result := 0 end"
 514                 write "end"
 515                 file.close
 516
 517                 for c in classes do
 518                         file = new OFStream.open("{name}/{c}.e")
 519                         write "class {c} "
 520                         if c.supers.is_empty then
 521                                 write "\tinherit ROOT"
 522                         else for s in [c.supers.first] do
 523                                 write "\tinherit {s}"
 524                         end
 525                         write "\t\tredefine id end"
 526                         write "feature"
 527                         write "\tid: INTEGER {istk} do Result := {c.id} end"
 528                         write "end"
 529                         file.close
 530                 end
 531
 532                 file = new OFStream.open("{name}/l.e")
 533                 write "class L[E]"
 534                 write "inherit ROOT"
 535                 write "create make"
 536                 write "feature"
 537                 write "\titem: E"
 538                 write "\tset_item(i: E) {istk} do item := i end"
 539                 write "\tnext: L[E]"
 540                 write "\tset_next(n: L[E]) {istk} do next := n end"
 541                 write "\tmake(i: E; n: L[E]) {istk} do set_item(i); set_next(n); end"
 542                 write "end"
 543                 file.close
 544
 545                 file = new OFStream.open("{name}/app{name}.e")
 546                 write "class APP{name.to_upper}"
 547                 if se then
 548                         write "insert ARGUMENTS"
 549                 end
 550                 write "create make"
 551                 write "feature"
 552                 write "fill: L[ROOT] {istk}"
 553                 write "local"
 554                 write "\ti: INTEGER"
 555                 write "do"
 556                 for c in classes do
 557                         write "\tcreate Result.make(create \{L[{c}]\}.make(create \{{c}\}, Void), Result)"
 558                 end
 559                 write "\tResult := Void;"
 560                 write "from i := 0 until i >= {arraylen} loop"
 561                 for i in [0..listlen[ do
 562                         var c = unlist[i]
 563                         write "\tcreate Result.make(create \{L[{c}]\}.make(create \{{c}\}, Void), Result)"
 564                 end
 565                 write "i := i + 1"
 566                 write "end"
 567                 write "end"
 568
 569                 write "run(head1: L[ROOT]; head2: L[ROOT]): INTEGER{istk}"
 570                 write "local"
 571                 write "\ty: INTEGER"
 572                 write "\tn1, n2: L[ROOT]"
 573                 for i in [0..listlen[ do
 574                         var c = list[i]
 575                         write "\t\tl{i}: ROOT"
 576                         write "\t\tlc{i}: L[{c}]"
 577                         write "\t\tc{i}: {c}"
 578                         write "\t\tl2_{i}: ROOT"
 579                         write "\t\tlc2_{i}: L[{c}]"
 580                 end
 581                 write "do"
 582                 write "\tfrom y := {loops/list.length}"
 583                 write "\tuntil y <= 0"
 584                 write "\tloop"
 585                 write "\tfrom"
 586                 write "\tn1 := head1"
 587                 write "\tn2 := head2"
 588                 write "\tuntil n1 = Void loop"
 589                 for i in [0..listlen[ do
 590                         var c = list[i]
 591                         write "\t\tl{i} := n1.item"
 592                         write "\t\tlc{i} ?= l{i}"
 593                         write "\t\tc{i} := lc{i}.item"
 594                         if count then
 595                                 write "\t\tif c{i}.id = {c.id} then Result := Result + 1 end"
 596                         end
 597                         write "\t\tl2_{i} := n2.item"
 598                         write "\t\tlc2_{i} ?= l2_{i}"
 599                         write "\t\tlc2_{i}.set_item(c{i})"
 600                         write "\t\tn1 := n1.next"
 601                         write "\t\tn2 := n2.next"
 602                 end
 603                 write "end"
 604                 write "y := y - 1"
 605                 write "end"
 606                 write "end"
 607
 608                 if se then
 609                         write "make{istk}"
 610                 else
 611                         write "make(args: ARRAY[STRING]){istk}"
 612                 end
 613                 write "local"
 614                 write "head: L[ROOT]"
 615                 write "loops: INTEGER"
 616                 write "cpt: INTEGER"
 617                 write "x: INTEGER"
 618                 write "do"
 619                 write "head := fill"
 620                 write "loops := 25"
 621                 if se then
 622                         write "if argument_count > 0 then loops := argument(1).to_integer"
 623                 else
 624                         write "if args.count > 1 then loops := args.item(1).to_integer"
 625                 end
 626                 write "from x := 0 until x>=loops loop"
 627                 write "\tcpt := run(head, head)"
 628                 write "\tprint(x.out+\":%T\"+cpt.out+\"%N\")"
 629                 write "\t x := x + 1"
 630                 write "end"
 631                 write "end"
 632                 write "end"
 633                 write "end"
 634                 file.close
 635         end
 636
 637         var count = false
 638 end
 639
 640 var g = new Generator
 641 var name = args.first
 642 if args.length > 1 then
 643         var opts = args[1].split_with("_")
 644         for opt in opts do
 645                 var oname = opt.substring(0,1)
 646                 var val = opt.substring_from(1).to_i
 647                 if oname == "l" then
 648                         g.listlen = val
 649                 else if oname == "w" then
 650                         g.width = val
 651                 else if oname == "h" then
 652                         g.height = val
 653                 else
 654                         print "Option inconnue '{oname}'"
 655                         exit(1)
 656                 end
 657         end
 658 end
 659 g.genhier
 660 g.writenit(name)
 661 g.writejava(name, true)
 662 g.writecsharp(name, true)
 663 g.writescala(name)
 664 g.writecpp(name)
 665 g.writee("{name}_se", true)
 666 g.writee(name, false)