;;; sol8.rkt - OPTION PF2 SCHEME AVANCE - Automne 2016
;;; Racket 6.6

#lang racket

(require "utils.rkt")   ; show, while

;;; --------------- Regular Expressions ---------------
(define str "Les images foo.jpg et bar.jpg sont belles !")

(show (regexp-match "c" "abcdec"))
(show (regexp-match "p" "abcdec"))
(show (regexp-match "." "abcdec"))
(show (regexp-match "[.]" "abcdec"))
(show (regexp-match* "x" "abcdec"))
(show (regexp-match "[.]jpg" str))
(show (regexp-match "[a-z]" "THX sound 2405"))
(show (regexp-match "[^A-Z]" "THX-sound 2005"))
(show (regexp-match "[^a-zA-Z-]" "THX-sound 2005"))
(show (regexp-match "[a-z]+" "THX-sound 2005"))
(show (regexp-match "[a-zA-Z]*[.]jpg" str))
(show (regexp-match* "[a-zA-Z]*[.]jpg" str))
(show (regexp-match "0|1" "45b1d08"))
(show (regexp-match "^ab" "abcde"))
(show (regexp-match "^ab" "cdabe"))
(show (regexp-match "de$" "abcde"))
(show (regexp-match "de$" "abdec"))
(show (regexp-match "colou?r" "color"))
(show (regexp-match "colou?r" "colour"))
(show (regexp-replace "gif|jpg" "lion.gif et jaguar.jpg" "bmp"))
(show (regexp-replace* "gif|jpg" "lion.gif et jaguar.jpg" "bmp"))
(printf "Attention a bien maitriser l'utilisation des parentheses dans une regexp,
elles permettent de numeroter les sous-regexp parenthesees :\n")
(show (regexp-match "([a-z]*)([0-9]+)([a-z]*)" "thx1138victory"))         ; --> (le-match sous-regexp-1 sous-regexp-2 sous-regexp-3)
(show (regexp-match "([a-zA-Z]+) ([0-9]+)" "en janvier 2010 je dois"))    ; --> (le-match sous-regexp-1 sous-regexp-2)
(show (regexp-replace "([a-z]*)([0-9]+)([a-z]*)" "thx1138victory" "\\3 <\\1> \\2"))
(printf "\n")

"----------------- TP 8 ------------------------------------------------"
"## Exo 1"

(define ALPHA
  (let ((code_a (char->integer #\a)))
    (build-string 26 (lambda (i) (integer->char (+ i code_a))))))

(show ALPHA)
(show (immutable? ALPHA))   ; ALPHA est mutable !

(define maj!
  (let ((dist (- (char->integer #\a) (char->integer #\A))))   ; calcul de dist a la compilation !
    (lambda (str)           ; str est supposee mutable
      (for ([i (in-range 0 (string-length str))])
        (define c (string-ref str i))
        (when (char<=? #\a c #\z)
          (string-set! str i (integer->char (- (char->integer c) dist))))))))

(define STEST (string-copy "Hello World !"))     ; mutable !
(show STEST)
(printf "Je mute STEST en majuscules :\n")
(maj! STEST)   ; aucun resultat
(show STEST)

"## Intermede sur let/ec"
; let/ec fait partie des "echappements" de Scheme, tout comme "return" et "break" sont les
; echappements de Python. Exemple : j'ai envie d'un "break" dans mon while comme en Python.
; Facile, je m'echappe...

(define x 0)
(let/ec break               ; vous pouvez remplacer break par tout autre mot comme fini, quitter, exit, etc.
  (while (< x 10)
    (printf "~a " x)
    (when (= x 5) (break))
    (set! x (+ x 1))))
(printf "\n")

"## Exo 2"

(define (position c str)  ; str est une string                ; def position(x,L) : 
  (define i 0)                                                ;     i = O
  (let/ec return          ; return n'existe pas !             ;     # le mot return existe deja...
    (while #t                                                 ;     while True : 
      (when (>= i (string-length str)) (return -1))           ;         if i >= len(L) : return -1
      (when (char=? (string-ref str i) c) (return i))         ;         if L[i] == x : return i
      (set! i (+ i 1)))))                                     ;         i = i + 1;

(show (list (position #\t "bateau") (position #\z "bateau")))

(define ($position c str)      ; quand meme plus standard...  ; def position(x,L) :
  (let/ec return                                              ;     # le mot return existe deja...
    (for ([i (in-range (string-length str))])                 ;     for i in range(len(str)) :
      (when (char=? c (string-ref str i))                     ;         if str[i] == c :
        (return i)))                                          ;             return i
    (return -1)))                                             ;     return -1

(show ($position #\t "bateau"))
(show ($position #\z "bateau"))

"## Exo 3"

(define (nb-blancs-en-tete str)
  (string-length (car (regexp-match " *" str))))

(show (map nb-blancs-en-tete '("" "abcde  " "   abcde" "     ")))

(define (premier-mot str)
  (define essai (regexp-match "[a-zA-Z]+" str))
  (and essai (car essai)))     ; <==> (if (equal? essai #f) #f (car essai))     :-)

(show (premier-mot "12345Anne-Marie!2010"))
(show (premier-mot "12345!2010"))

(require racket/date)            ; la librairie sur les dates et l'heure courante

(define (today)
  ; un DICTIONNAIRE Python est une TABLE DE HASH-CODE en Scheme, acces en O(1) donc mieux qu'une A-liste qui est en O(n)...
  (define DICT (hash "January" 1 "February" 2 "March" 3 "April" 4 "May" 5 "June" 6 "July" 7     ; voir la doc de hash !
                     "August" 8 "September" 9 "October" 10 "November" 11 "December" 12))
  (define (month->number mois)
    (hash-ref DICT mois))
  (define sol (regexp-match "([a-zA-Z]+) ([0-9]+)[^0-9]*([0-9]+)" (date->string (current-date))))   ; parentheses !!!
  (list (string->number (third sol)) (month->number (second sol)) (string->number (fourth sol))))

(show (today))

"## Exo 4"
; Je fais des print dans les versions ci-dessous, donc aucun resultat. Tachez d'en produire une version 
; qui rende une string (qui contiendra des sauts de ligne)... Avec les fichiers du cours 9 on pourrait aussi
; rediriger la sortie vers une string !

(define (scheme->python A AL)
  (define (prefixe->infixe A)
    (if (not (pair? A))     ; feuille ?
        A
        (list (prefixe->infixe (second A)) (first A) (prefixe->infixe (third A)))))
  (printf "def ~a() :           # mon premier compilateur Scheme --> Python !\n" (gensym 'func))
  (for ([L (in-list AL)])
    (define var (car L)) 
    (define val (cadr L))
    (printf "    ~a = ~a\n"
            var 
            (if (integer? val) val (exact->inexact val))))
  (printf "    return ~a" (prefixe->infixe A))
  (printf "\n"))

(define A '(+ (* (+ x 1) 2) y))
(define AL '((x 3) (y -1/4)))
(printf "Je traduis automatiquement l'arbre ~a en une fonction Python\n" A)
(printf "dans une memoire ~a :\n\n" AL)
(scheme->python '(+ (* (+ x 1) 2) y) '((x 3) (y -1/4)))

;;; Le meme en Java

(define (scheme->java A AL)
  (define (prefixe->infixe A)
    (if (not (pair? A))     ; feuille ?
        A
        (list (prefixe->infixe (second A)) (first A) (prefixe->infixe (third A)))))
  (printf "double ~a() {        # mon premier compilateur Scheme --> C/Java !\n" (gensym 'func))      ; gensym !!!
  (for ([L (in-list AL)])
    (define var (car L)) 
    (define val (cadr L))
    (printf "   ~a ~a = ~a;\n"
            (if (integer? val) "int" "double") 
            var 
            (if (integer? val) val (exact->inexact val))))
  (printf "   return ~a;\n" (prefixe->infixe A))
  (printf "}\n"))

(printf "\nJe traduis automatiquement l'arbre ~a en une fonction Java\n" A)
(printf "dans une memoire ~a :\n\n" AL)
(scheme->java '(+ (* (+ x 1) 2) y) '((x 3) (y -1/4)))

(require racket/system)
; Guile est le langage extensible de GNU, la fondation du logiciel libre !!
(system "open http://www.gnu.org/software/guile/guile.html")