COMPILATEUR V 0.9 beta 10 du 29 aout 2017

if left$(traduction_mot$,34)="Ne pas traduire ce mot en tant que"
   b$="$"
   traduction_mot$=mot_a_traduire$
end_if

if instr(trim$(traduction_mot$)," ")>0
   position%=1
   while 0=0
            x%=instr_pos(traduction_mot$," ",position%)
            if x%=0 then exit_while
                        
            traduction_mot$=left$(traduction_mot$,x%)+car$+right_pos$(traduction_mot$,x%+1)
            position%=x%+2
   end_while
end_if

END

list 10 : top 10,50 : left 10,100 : height 10,300
Afficher_Recursif(1.1)
end
SUB Afficher_Recursif(a%,b%)
    if a% < 4
       if b% < 10
          item_add 10,str$(a%*10+b%)
          Afficher_Recursif(a%,b%+1)
       else
          Afficher_Recursif(a%+1,0)
       end_if
    end_if
END_SUB

dim traduction_mot$,b$,mot_a_traduire$

if left$(traduction_mot$,34)="Ne pas traduire ce mot en tant que"
  b$="$"
  traduction_mot$=mot_a_traduire$
end_if

dim traduction_mot$,x%,position%

if instr(trim$(traduction_mot$)," ")>0
  position%=1
  while 0=0
            x%=instr_pos(traduction_mot$," ",position%)
            if x%=0 then exit_while
                       
            traduction_mot$=left$(traduction_mot$,x%)+car$+right_pos$(traduction_mot$,x%+1)
            position%=x%+2
  end_while
end_if

rem ============================================================================
rem         calcul des 1000 premières décimales de PI
rem ============================================================================
Init()
Pi1000()
end
rem ============================================================================
SUB Init()
    dim t(202), nmax, b, d, p, q, r, n, m, i, tex$,aff$
    width 0,1000
    caption 0,"LES 1000 PREMIERES DECIMALES DE PI"
    alpha 10 : top 10,10 : left 10,10 : font_bold 10 : font_name 10,"arial"
    font_size 10,18 : caption 10,string$(30," ") + "LES 1000 PREMIERES DECIMALES DE PI"
    font_color 10,0,0,255
    alpha 20 : top 20,50 : left 20,10 : font_bold 20 : font_name 20,"arial"
    font_size 20,14 : font_color 20,150,100,50
END_SUB
rem ============================================================================
SUB Pi1000()
    nmax = 3340
    b = 100000
    for i = 1 to 201 : t(i) = 0 : next i : ' On initialise les calculs  
    T(0) = 2 * nmax     : ' t(0) = 2n, les autres tranches sont nulles
     d = 2 * nmax + 1   : ' le diviseur est 2n+1
    Divise()
    for n = nmax to 2 STEP -1  : ' Boucle de l'algorithme
        T(0) = T(0) + 2 : d = 2 * n - 1 : Divise()
        m = n - 1 : Multiplie()
    NEXT n
    T(0) = T(0) + 2
    Affiche()
END_SUB
rem ============================================================================
SUB Divise()
    FOR i = 0 TO 201
       q = INT(T(i)/d) : r = T(i) - d * q
       T(i) = q : T(i+1) = T(i+1) + b * r
    NEXT i
END_SUB
rem ============================================================================
SUB Multiplie()
    q = 0
    FOR i = 201 TO 1 STEP -1
        p = T(i) * m + q : q = INT(p/b) : T(i) = p - q * b
    NEXT i
    T(0) = T(0) * m + q
END_SUB
rem ============================================================================
SUB Affiche()
    aff$ = str$(t(0)) + "." + chr$(13)
    for i = 1 to 200
        tex$ = str$(t(i))
        WHILE LEN(tex$) < 5   : ' si les tranches t(i) comporte des zéros au début
            tex$ = "0" + tex$ : ' les compléter à 5 chiffres en ajoutant les zéros nécessaires
        END_WHILE
        tex$ = " " + tex$     : ' espace de séparation des tranches de 5 chiffres
        aff$ = aff$ + tex$    : ' Toutes les tranches sont stockées dans la variable d'affichage
        IF MOD(i,16) = 0 THEN aff$ = aff$ + chr$(13) : ' Chaque ligne comporte 16 tranches
    NEXT i
    caption 20, aff$
END_SUB
rem ===========================================================================

rem ============================================================================
rem                      Tracé récursif d’arbres
rem        Exploitant les Turtle_Routines, Procédures de la Tortue
rem               Programme pour tester le Compilateur
rem                    Par Papydall 03 / 08 / 2017
rem ============================================================================
rem Le programme utilise des routines pour piloter une tortue, un peu comme
rem la fameuse Turtle du langage LOGO (Voir à partir de la ligne 134
rem ============================================================================

 Init_Turtle()

 Init_prog()
 La_Maison(0,300,1)  : La_Maison(300,300,1) : La_Maison(1000,200,1/2)
 La_Maison(1200,200,1/4)
 
 Bel_Arbre(0,-100,450)
 Arbre_Simple(-300,-200,150,45)
 Arbre_Penche(300,-400,150,50)
 
 Bel_Arbre(-500,-200,250)
 Arbre_Simple(200,-200,50,45)

end
rem ============================================================================
SUB Init_prog()
    dim_local x,y,p,towpi
    p = pi/180 : towpi = 2*pi
    2d_poly_from 0,height(0)/3
    for x = 0 to 2*pi step p
        2d_poly_to x*width(0)/towpi,height(0)/4+50*sin(x)
    next x
    2d_flood 10,10 , 50,100,150 : 2d_flood 10,height(0)/2,100,150,50
END_SUB
rem ============================================================================
' Arbre droit
SUB Arbre_Simple(x,y,l,a)
    Pen_Up(): Fixe_XY(x,y) : Back(160) : Pen_Down()
    Tree_Simple(l,a,l)
END_SUB
' ------------------------------------------------------------------------------
SUB Tree_Simple(length,angle,f)
   if length < 5
        ' ne rien faire
   else
      2d_pen_width length/9  : ' reduction
      2d_pen_color 200,255*(f-length)/(f),50 : ' couleur dépend de la longueur
      Forward(length) : Turn_Left(angle/2)
      Tree_Simple(length*0.75,angle,f) : Turn_Right(angle) : ' longueur branche 3/4
      Tree_Simple(length*0.75,angle,f) : Turn_Left(angle/2)
      Pen_Up() : Back(length) : Pen_Down()
   end_if
END_SUB
rem ============================================================================
' Procédure récursive de tracé d'un bel arbre
SUB Bel_Arbre(x,y,taille)
    Pen_Up(): Fixe_XY(x,y) : Back(160) : Pen_Down()
    Arbre(taille,taille)
END_SUB
' ------------------------------------------------------------------------------
SUB Arbre(taille,f)
    if taille < 5
       forward(taille) : Back(taille)
    else
       2d_pen_width 8
       caption 0,str$(255*(f-taille)/(f))
       2d_pen_color 20,255,50
       forward(taille/3) : turn_left(30)  : Arbre(taille*2/3) : turn_right(30)
       forward(taille/6) : turn_right(25) : Arbre(taille/2)   : turn_left(25)
       forward(taille/3) : turn_right(25) : Arbre(taille/2)   : turn_left(25)
       forward(taille/6) : forward(0-taille)
    end_if
END_SUB
rem ============================================================================
' Arbre penché vers la droite
SUB Arbre_Penche(x,y,l,a)
    Pen_Up(): Fixe_XY(x,y) : Turn_Right(5) : Pen_Down()
    Tree_Penche(l,a,l)
END_SUB
' ------------------------------------------------------------------------------
SUB Tree_Penche(length,angle,f)
    if length < 5
        ' ne rien faire
    else
      2d_pen_width length/9
      2d_pen_color 255,255*(f-length)/(f),0
      Forward(length) : Turn_Left(angle/2)
      Tree_Penche(length*0.65,angle,f) : Turn_Right(angle)
      Tree_Penche(length*0.85,angle,f) : Turn_Left(angle/2)
      Pen_Up() : Back(length) : Pen_Down()
    end_if
END_SUB
rem ============================================================================
' x,y : Coordonnées du début du toit
' e   : Facteur d'aggrandissement / rapetissement
SUB La_Maison(x,y,e)
    2d_pen_color 0,0,255      : 2d_poly_from x+80*e,y+20*e
    2d_poly_to x+220*e,y+20*e : 2d_poly_to x+280*e,y+80*e
    2d_poly_to x+140*e,y+80*e : 2d_poly_to x+80*e,y+20*e
    2d_flood x+220*e,y+20*e+5,0,0,255
    2d_pen_color 100,50,20  : 2d_fill_color 100,50,20
    2d_rectangle x+140*e,y+80*e,x+270*e,y+170*e

    2d_pen_color 50,100,50    : 2d_poly_from x+87*e,y+27*e
    2d_poly_to x+140*e,y+80*e : 2d_poly_to x+140*e,y+170*e
    2d_poly_to x+30*e,y+170*e : 2d_poly_to x+30*e,y+80*e
    2d_poly_to x+87*e,y+27*e  : 2d_flood x+30*e+10,y+80*e, 200,200,50

    2d_pen_color 0,0,0        : 2d_poly_from x+80*e,y+20*e
    2d_poly_to x+87*e,y+27*e  : 2d_poly_to x+30*e,y+80*e
    2d_poly_to x+20*e,y+80*e  : 2d_poly_to x+80*e,y+20*e
    2d_flood x+80*e,y+20*e+2,0,0,0
    2d_fill_color 0,0,0
    2d_rectangle x+20*e,y+170*e,x+280*e,y+180*e : 2d_rectangle x+170*e,y+90*e,x+240*e,y+155*e

    2d_fill_color 255,255,0
    2d_rectangle x+175*e,y+95*e,x+202*e,y+120*e  : 2d_rectangle x+208*e,y+95*e,x+235*e,y+120*e
    2d_rectangle x+175*e,y+125*e,x+202*e,y+150*e : 2d_rectangle x+208*e,y+125*e,x+235*e,y+150*e

    2d_fill_color 0,200,200 : 2d_rectangle x+60*e,y+80*e,x+110*e,y+170*e
    2d_fill_color 0,0,0     : 2d_rectangle x+195*e,y+15*e,x+205*e,y+30*e
    2d_poly_from x+200*e,y+10*e
    2d_poly_to x+210*e,y+15*e : 2d_poly_to x+190*e,y+15*e : 2d_poly_to x+200*e,y+10*e
    2d_flood x+200*e,y+10*e+2,0,0,0
    2d_fill_color 255,255,0 : 2d_circle x+100*e,y+120*e,5*e

    2d_fill_color 255,0,0
END_SUB
rem ============================================================================

rem ============================================================================
rem ############################################################################
rem ============================================================================
rem               LES PROCEDURES DE LA TORTUE  : Turtle_Routines
rem ============================================================================
rem ############################################################################
rem Les variables globales Turtle_XXX sont prédéfinies pour les routines TORTUE.
rem Votre programme ne doit ni les redéfinir ni les modifier.
rem Ce sont :
rem Turtle_Xorigine,Turtle_Yorigine : coordonnées de l’origine (le centre de l’écran)
rem Turtle_X,Turtle_Y : coordonnées relatives de la tortue (par rapport à l’origine)
rem Turtle_Cap : direction initiale du déplacement de la tortue : vers le haut
rem Turtle_PI  : la constante Pi
rem Turtle_rad : multiplicateur pour transformer les degrés en radians
rem ============================================================================
rem REMARQUE IMPORTANTE :
rem L’origine des axes est le centre de la fenêtre
rem Le sens positif sur l’axe des X est dirigé vers la droite (négatif vers la gauche)
rem Le sens positif sur l’axe des Y est dirigé vers le haut (négatif vers le bas)
rem ============================================================================
' Initialisation de la tortue graphique
' La tortue se trouve au centre de la fenêtre et est dirigée vers le Nord
SUB Init_Turtle()
    dim Turtle_Xorigine,Turtle_Yorigine :' coordonnées de l'origine (le centre de l'écran)
    dim Turtle_X,Turtle_Y : ' coordonnées relatives de la tortue (par rapport à l'origine)
    dim Turtle_Cap        : ' direction initiale du déplacement de la tortue vers le haut
    dim New_Turtle_Cap    : ' Nouveau cap de la tortue
    dim Turtle_PI         : ' la constante Pi
    dim Turtle_rad        : ' multiplicateur pour transformer les degrés en radians
    dim Turtle_R, Turtle_G, Turtle_B    : ' RGB du tracé
    dim Turtle_FR, Turtle_FG, Turtle_FB : ' RGB du fond
    dim Turtle_Pen_Up_Down              : ' Etat du crayon (0 = baissé) ; (1 = levé)
    full_space 0
    Turtle_Pen_Up_Down = 0              : ' crayon baissé au départ
    Turtle_Xorigine = width(0)/2        : ' L'origine de ...
    Turtle_Yorigine = height(0)/2-20    : ' ... l'écran graphique

    Turtle_PI  = pi            : ' pi
    Turtle_Cap = Turtle_PI/2   : ' La tortue est dirigée vers le haut
    Turtle_rad = Turtle_PI/180 : ' Facteur multiplicateur pour les angles (degrés --> radians)

    Origine()
END_SUB
rem ============================================================================
' Pour débuter un nouveau dessin
' Effacer l'écran et remettre la tortue à sa place
' (au centre de la fenêtre et dirigée vers le nord)
SUB Nouveau()
    cls : Origine()
END_SUB
rem ============================================================================
' Ramener la tortue à l'origine (c-à-d au centre de la fenêtre)
SUB Origine()
    Turtle_X = Turtle_Xorigine : Turtle_Y = Turtle_Yorigine
    New_Turtle_Cap = Turtle_Cap  : 2d_poly_from Turtle_X,Turtle_Y
END_SUB
rem ============================================================================
' Avancer de pas pixels
' Si le crayon est baissé, la tortue trace un trait avec la couleur en cours
' Si le crayon est levé, la tortue se déplace sans laisser de trace
SUB Forward(pas)
    dim_local x1,y1,x2,y2,a
    x1 = Turtle_X : y1 = Turtle_Y : a  = New_Turtle_Cap
    x2 = Turtle_X + pas * cos(a)  : y2 = Turtle_Y - pas * sin(a)

    if Turtle_Pen_Up_Down = 0 : ' crayon baissé ?
       2d_poly_to x2,y2       : ' on trace le trait avec la couleur en cours
    else : ' crayon levé
       2d_poly_from x2,y2     : ' on se déplace sans trace
    end_if
    Turtle_X = x2 : Turtle_Y = y2
END_SUB
rem ============================================================================
' Réculer de pas pixels
' Si le crayon est baissé, la tortue trace un trait avec la couleur en cours
' Si le crayon est levé, la tortue se déplace sans laisser de trace
SUB Back(pas)
    Forward(0-pas)
END_SUB
rem ============================================================================
' Tourner à gauche (sens trigonométrique) de a degrés
SUB Turn_Left(a)
    New_Turtle_Cap = New_Turtle_Cap + a * Turtle_rad
END_SUB
rem ============================================================================
' Tourner à droite (sens horaire) de a degrés
SUB Turn_Right(a)
    New_Turtle_Cap = New_Turtle_Cap - a * Turtle_rad
END_SUB
rem ============================================================================
' Fixer le Cap de la tortue
' Le Cap est la direction du déplacement de la tortue :
' 000 c'est vers la droite (EST)
' 090 c'est vers le haut (NORD)
' 180 c'est vers la gauche (OUEST)
' 270 c'est vers le bas (SUD)
' 360 c'est identique à 000
SUB Fixe_Cap(a)
    New_Turtle_Cap = a * Turtle_rad
END_SUB
rem ============================================================================
' Fixer la position X de la tortue par rapport à l'origine
' Déplacement horizontal
SUB FixeX(n)
    Turtle_X = Turtle_Xorigine + n : 2d_poly_from Turtle_X,Turtle_Y
END_SUB
rem ============================================================================
' Fixer la position Y de la tortue par rapport à l'origine
' Déplacement vertical
rem ############################################################################
rem   REMARQUE IMPORTANTE : le sens posif pour les Y est le sens vers le haut
rem ############################################################################
SUB FixeY(n)
    Turtle_Y = Turtle_Yorigine - n : 2d_poly_from Turtle_X,Turtle_Y
END_SUB
rem ============================================================================
' Fixer la position de la tortue
' Déplacer la tortue au point (X,Y) par rapport au centre de la
' fenêtre qui est l'origine.
' X et/ou Y peuvent être positives, négatives ou nulles
SUB Fixe_XY(x,y)
    Turtle_X = Turtle_Xorigine + x : Turtle_Y = Turtle_Yorigine - y
    2d_poly_from Turtle_X,Turtle_Y
END_SUB
rem ============================================================================
' Tracer l'axe des X
SUB AxeX()
    2d_line 0,Turtle_Yorigine,2*Turtle_Xorigine,Turtle_Yorigine
END_SUB
rem ============================================================================
' Tracer l'axe des Y
SUB AxeY()
    2d_line Turtle_Xorigine,0,Turtle_Xorigine,2*Turtle_Yorigine
END_SUB
rem ============================================================================
' Tracer les 2 axes X et Y
SUB Axe_XY()
    AxeX() : AxeY()
END_SUB
rem ============================================================================
' On modifie l'état du crayon
' Lever le stylo : le déplacement de la tortue ne laisse pas de trace
SUB Pen_Up()
    Turtle_Pen_Up_Down = 1
END_SUB
rem ============================================================================
' On modifie l'état du crayon
' Baisser le stylo : le déplacement de la tortue laisse une trace
SUB Pen_Down()
    Turtle_Pen_Up_Down = 0
END_SUB
rem ============================================================================
' Définition des 17 couleurs par leur nom
SUB Define_Color(couleur$)
    dim_local r,g,b,c$   : c$ = upper$(couleur$)
    if c$ = "NOIR"       : r = 000 : g = 000 : b = 000 : end_if
    if c$ = "ROUGE"      : r = 255 : g = 000 : b = 000 : end_if
    if c$ = "VERT"       : r = 000 : g = 255 : b = 000 : end_if
    if c$ = "JAUNE"      : r = 255 : g = 255 : b = 000 : end_if
    if c$ = "BLEU"       : r = 000 : g = 000 : b = 255 : end_if
    if c$ = "MAGENTA"    : r = 255 : g = 000 : b = 255 : end_if
    if c$ = "CYAN"       : r = 000 : g = 255 : b = 255 : end_if
    if c$ = "BLANC"      : r = 255 : g = 255 : b = 255 : end_if
    if c$ = "GRIS"       : r = 128 : g = 128 : b = 128 : end_if
    if c$ = "GRISCLAIR"  : r = 192 : g = 192 : b = 192 : end_if
    if c$ = "ROUGEFONCE" : r = 128 : g = 000 : b = 000 : end_if
    if c$ = "VERTFONCE"  : r = 000 : g = 128 : b = 000 : end_if
    if c$ = "BLEUFONCE"  : r = 000 : g = 000 : b = 128 : end_if
    if c$ = "ORANGE"     : r = 255 : g = 200 : b = 000 : end_if
    if c$ = "ROSE"       : r = 255 : g = 175 : b = 175 : end_if
    if c$ = "VIOLET"     : r = 128 : g = 000 : b = 255 : end_if
    if c$ = "MARRON"     : r = 153 : g = 102 : b = 000 : end_if

    Turtle_R = r :  Turtle_G = g :Turtle_B = b
END_SUB
rem ============================================================================
' Fixer la couleur du tracé
SUB Fixe_Pen_Color(couleur$)
    Define_Color(couleur$) : 2d_pen_color Turtle_R, Turtle_G, Turtle_B
END_SUB
rem ============================================================================
' Fixer la couleur du fond
SUB Fixe_Fond_Color(couleur$)
    Define_Color(couleur$)
    Turtle_FR =  Turtle_R :  Turtle_FG = Turtle_G :  Turtle_FB = Turtle_B
    color 0, Turtle_FR, Turtle_FG, Turtle_FB
END_SUB
rem ============================================================================
' La tortue efface tous les traits qu’elle rencontre
SUB Pen_Erase()
    2d_pen_color Turtle_FR, Turtle_FG, Turtle_FB
END_SUB
rem ============================================================================
' Inverser la couleur du crayon
SUB Pen_Invert()
    2d_pen_color 255 - Turtle_R, 255 - Turtle_G, 255 - Turtle_B
END_SUB
rem ============================================================================
SUB Pen_Paint(couleur$)
    Define_Color(couleur$)
    Turtle_FR =  Turtle_R :  Turtle_FG = Turtle_G :  Turtle_FB = Turtle_B
    2d_flood Turtle_X, Turtle_Y, Turtle_FR, Turtle_FG, Turtle_FB
END_SUB
rem ============================================================================
rem ############################################################################
rem ============================================================================