automate: aString  
   | c x |  
   c := 1.  
   aString  
      do: [:ele |  
         c := c + 1.  
         (x := ’Ff+-[]|!’ indexOf: ele) > 0  
            ifTrue: [self  
                  perform: (#(#avance #avancef #plus #moins  
                              #empile #depile #inverseDir #inverse )  
                            at: x)]  
            ifFalse: [(x := ’C\/@<>’ indexOf: ele) > 0  
                  ifTrue: [self  
                        perform: (#(#color: #increase: #decrease:  
                                    #changeLineLength: #incrColor:  
                                    #decrColor: ) at: x)  
                        with: (aString copyFrom: c  
                                             to: aString size)  
                              asNumber]]]

avance  
   pen go: longueur

avancef  
   pen up; go: longueur; down

color: aNumber  
   couleur := aNumber.  
   pen color: aNumber

decrColor: aNumber  
   self incrColor: 0 - aNumber

decrease: aNumber  
   etat  
      ifTrue: [pen turn: 0 - aNumber]  
      ifFalse: [pen turn: aNumber]

depile  
   longueur := pile removeFirst.  
   pen  
      location: pile removeFirst  
      direction: pile removeFirst  
      penDown: pile removeFirst

empile  
   pile addFirst: pen penDown.  
   pile addFirst: pen direction.  
   pile addFirst: pen location.  
   pile addFirst: longueur

getDerivations: n  
   | tmp |  
   tmp := FillInTheBlank request: ’derivation ’ , n asString , ’ ?’  
                   initialAnswer: ’’.  
   tmp := tmp copyWithoutAll: {32 asCharacter. 9 asCharacter}.  
   "espace"  
   "tabulation"  
   tmp = ’’  
      ifTrue: [^ nil]  
      ifFalse: [reglesDerivation  
            at: (tmp at: 1)  
            put: (tmp copyFrom: 3 to: tmp size).  
         self getDerivations: n + 1]

incrColor: aNumber  
   pen  
      color: (colorMap atWrap: (couleur := couleur + aNumber))

increase: aNumber  
   etat  
      ifTrue: [pen turn: aNumber]  
      ifFalse: [pen turn: 0 - aNumber]

inverse  
   etat := etat not

inverseDir  
   pen turn: 180

plus  
   pen  
      turn: (etat  
            ifTrue: [angle]  
            ifFalse: [0 - angle])

moins  
   pen  
      turn: (etat  
            ifTrue: [0 - angle]  
            ifFalse: [angle])

remplace: aString  
   | tmp |  
   ^ aString  
      inject: ’’  
      into: [:new :ele |  
            (tmp := reglesDerivation at: ele ifAbsent: nil) isNil  
            ifTrue: [new , ele asString]  
            ifFalse: [new , tmp]]

remplace: aString times: n  
   ^ n = 0  
      ifTrue: [aString]  
      ifFalse: [self  
            remplace: (self remplace: aString)  
            times: n - 1]