cargo new projet

1
2
3
4
[lib]
name = "projet"
crate-type = ["dylib"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
use std::ffi::CString; 
use std::ffi::CStr; 
use std::os::raw::c_char; 
 
#[no_mangle] // 
pub extern fn depuis_rust() -> *const c_char {
    let s = CString::new("& oui").unwrap();
    let p = s.as_ptr(); 
    std::mem::forget(s); 
    p 
} 
 
#[no_mangle]
pub extern fn vers_rust( texte: *const c_char) -> *const c_char { 
    let cstr = unsafe { 
        CStr::from_ptr( texte ) 
    }; 
    let string = cstr.to_str().expect("chaine UTF-8 invalide");
    println!("{}", string); 
    let s = CString::new("@ maison").unwrap();
    let p = s.as_ptr();
    std::mem::forget(s);
    p 
}

cargo build --release

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import ctypes 

lib = ctypes.cdll.LoadLibrary("./target/release/libembed.so")

l = lib.depuis_rust() 

print( ctypes.c_char_p( l ).value ) 

l2 = lib.vers_rust( 
    ctypes.c_char_p( 
        "tout ça : ²&é\"'(-è_çà)=".encode('utf-8') 
    ) 
) 

print( ctypes.c_char_p( l2 ).value )

1
2
3
b'& oui'
tout ça : ²&é"'(-è_çà)=
b'@ maison'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
// #![allow(dead_code)] 
// #![allow(unused_must_use)] 

#[derive(Debug)] 
enum Atom { 
	EspaceNul, 
	ParentheseOuvrante, 
	ParentheseFermante, 
	Texte { debut: usize, fin: usize, contenu: Vec<char> },  
	Espaces { debut: usize, fin: usize, contenu: Vec<char> }, 
	Chiffres { debut: usize, fin: usize, contenu: Vec<char> }, 
	Lettres { debut: usize, fin: usize, contenu: Vec<char> }, 
}

#[derive(Debug)] 
struct Request { 
	chaine: String, 
	indice: usize, 
	arbre: Vec<Atom>
} 

fn is( requete: &mut Request, cherche: Vec<char>, debut: usize ) -> Result<char, usize> { 
	for (i, c) in requete.chaine.chars().enumerate() { 
    	if i>=debut { 
	    	if cherche.contains( &c ) { 
				return Result::Ok( c ); 
	    	} else { 
	    		return Result::Err( debut ); 
	    	} 
    	} 
	} 
	return Result::Err( debut ); 
} 

fn space( requete: &mut Request, debut: usize ) -> Result<char, usize> { 
	is( 
		requete, 
		vec![ '\r', '\n', '\t', ' ' ], 
		debut 
	) 
} 

fn spaces( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	let mut signes = Vec::new(); 
	while let Result::Ok( s ) = space( requete, i ) { 
		if ajout { 
			signes.push( s ); 
		} 
		i = i+1; 
	} 
	if i==debut { 
		Result::Err( debut ) 
	} else { 
		if ajout { 
			requete.arbre.push( Atom::Espaces { 
				debut: debut, 
				fin: i, 
				contenu: signes 
			} ); 
		} 
		Result::Ok( i ) 
	} 
} 

fn letter( requete: &mut Request, debut: usize ) -> Result<char, usize> { 
	is( 
		requete, 
		vec![ 
			'a', 'b', 'c', 'd', 'e', 'f', 
			'g', 'h', 'i', 'j', 'k', 'l', 
			'm', 'n', 'o', 'p', 'q', 'r', 
			's', 't', 'u', 'v', 'w', 'x', 
			'y', 'z' 
		], 
		debut 
	) 
} 

fn letters( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	let mut signes = Vec::new(); 
	while let Result::Ok( s ) = letter( requete, i ) { 
		if ajout { 
			signes.push( s ); 
		} 
		i = i+1; 
	} 
	if i==debut { 
		Result::Err( i ) 
	} else { 
		if ajout { 
			requete.arbre.push( Atom::Lettres { 
				debut: debut, 
				fin: i, 
				contenu: signes 
			} ); 
		} 
		Result::Ok( i ) 
	} 
} 

fn number( requete: &mut Request, debut: usize ) -> Result<char, usize> { 
	is( 
		requete, 
		vec![ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ], 
		debut 
	) 
} 

fn numbers( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	let mut signes = Vec::new(); 
	while let Result::Ok( s ) = number( requete, i ) { 
		if ajout { 
			signes.push( s ); 
		} 
		i = i+1; 
	} 
	if i==debut { 
		Result::Err( debut ) 
	} else { 
		if ajout {
			requete.arbre.push( Atom::Chiffres { 
				debut: debut, 
				fin: i, 
				contenu: signes 
			} ); 
		}
		Result::Ok( i ) 
	} 
} 

fn text( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	let mut text: Vec<char> = Vec::new(); 
	if let Result::Ok( s ) = is( requete, vec![ '"' ], debut ) { 
		let mut precedent = s; 
		text.push( s ); 
		for (n, c) in requete.chaine.chars().enumerate() { 
	    	if n>=debut+1 { 
	    		match c { 
	    			'"' if precedent != '\\' => { 
	    				if ajout {
		    				requete.arbre.push( Atom::Texte { 
								debut: debut, 
								fin: n, 
								contenu: text  
							} ); 
	    				}
						return Result::Ok( n+1 ); 
	    			}, 
	    			'"' if precedent == '\\' => { 
	    				precedent = c; 
    					text.push( c ); 
	    			} 
	    			_ => {
	    				precedent = c; 
	    				text.push( c ); 
	    			}, 
	    		} 
	    	} 
		} 
	} 
	return Result::Err( debut ); 
} 

fn atom( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	if let Result::Ok( v ) = text( requete, debut, ajout ) { 
		return Result::Ok( v ); 
	} 
	if let Result::Ok( v ) = letters( requete, debut, ajout ) { 
		return Result::Ok( v ); 
	} 
	if let Result::Ok( v ) = numbers( requete, debut, ajout ) { 
		return Result::Ok( v ); 
	} 
	Result::Err( debut ) 
} 

fn atoms( requete: &mut Request, debut: usize ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	while let Result::Ok( y ) = atom( requete, i, true ) { 
		i = y; 
	} 
	if i==debut { 
		Result::Err( debut ) 
	} else { 
		Result::Ok( i ) 
	} 
} 

fn list( requete: &mut Request, debut: usize ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	if let Result::Ok( .. ) = is( requete, vec![ '(' ], i ) { 
		i = i+1; 
		requete.arbre.push( Atom::ParentheseOuvrante ); 
		while let Result::Ok( y ) = expression( requete, i ) { 
			i = y; 
		} 
		if let Result::Ok( .. ) = is( requete, vec![ ')' ], i ) { 
			requete.arbre.push( Atom::ParentheseFermante ); 
			return Result::Ok( i+1 ); 
		} 
	} 
	return Result::Err( debut ); 
} 

fn nettoyer( requete: &mut Request, debut: usize ) -> usize { 
	if let Result::Ok( v ) = spaces( requete, debut, false ) { 
		requete.arbre.push( Atom::EspaceNul ); 
		return v; 
	} else { 
		return debut; 
	} 
} 

fn expression( requete: &mut Request, debut: usize ) -> Result<usize, usize> { 
	let mut i: usize = nettoyer( requete, debut ); 
	if let Result::Ok( y ) = list( requete, i ) { 
		i = y;  
	} else { 
		if let Result::Ok( y) = atoms( requete, i ) { 
			i = y; 
		} 
	} 
	if i==debut {  
		Result::Err( debut ) 
	} else { 
		Result::Ok( i ) 
	} 
} 

fn resoudre( requete: &mut Request ) -> Result<usize, usize> { 
	let mut i: usize = requete.indice; 
	while let Result::Ok( y ) = expression( requete, i ) { 
		i = y; 
	} 
	requete.indice = nettoyer( requete, i ); 
	if requete.indice!=requete.chaine.chars().count() {
		return Result::Err( requete.indice ); 
	} else { 
		return Result::Ok( requete.indice ); 
	} 
} 

fn main() { 

	let mut requetes = Vec::new(); 

	requetes.push( 
		Request{ 
	    	chaine: "123".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "abc".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "	\"ab\\\"cd\"	".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "	\"a\\\"bc\"\"	".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "(123)".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "(123 (abc))".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }
	); 

	requetes.push( 
		Request{ 
	    	chaine: "(123 (abc".to_string(), 
	    	indice: 0, 
	    	arbre: Vec::new()  
	    }, 
	); 

    for r in requetes { 
    	println!("---------------"); 
    	let mut requete = r; 
	    if let Result::Ok( .. ) = resoudre( &mut requete ) { 
	    	println!( "\nLe parsing s'est correctement déroulé {:?}", requete ); 
	    } else { 
	    	println!( "\nAttention, l'expression donnée \n{:?}\n... n'est pas valide LISP", requete.chaine ); 
	    } 
	    println!(""); 
	} 

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
julien@rdfnquads:~/dev/rust/rustlispparser$ cargo run
   Compiling rustlispparser v0.1.0 (/home/julien/dev/rust/rustlispparser)
    Finished dev [unoptimized + debuginfo] target(s) in 0.78s
     Running `target/debug/rustlispparser`
---------------

Le parsing s'est correctement déroulé Request { chaine: "123", indice: 3, arbre: [Chiffres { debut: 0, fin: 3, contenu: ['1', '2', '3'] }] }

---------------

Le parsing s'est correctement déroulé Request { chaine: "abc", indice: 3, arbre: [Lettres { debut: 0, fin: 3, contenu: ['a', 'b', 'c'] }] }

---------------

Le parsing s'est correctement déroulé Request { chaine: "\t\"ab\\\"cd\"\t", indice: 10, arbre: [EspaceNul, Texte { debut: 1, fin: 8, contenu: ['\"', 'a', 'b', '\\', '\"', 'c', 'd'] }, EspaceNul] }

---------------

Attention, l'expression donnée
"\t\"a\\\"bc\"\"\t"
... n'est pas valide LISP

---------------

Le parsing s'est correctement déroulé Request { chaine: "(123)", indice: 5, arbre: [ParentheseOuvrante, Chiffres { debut: 1, fin: 4, contenu: ['1', '2', '3'] }, ParentheseFermante] }

---------------

Le parsing s'est correctement déroulé Request { chaine: "(123 (abc))", indice: 11, arbre: [ParentheseOuvrante, Chiffres { debut: 1, fin: 4, contenu: ['1', '2', '3'] }, EspaceNul, ParentheseOuvrante, Lettres { debut: 6, fin: 9, contenu: ['a', 'b', 'c'] }, ParentheseFermante, ParentheseFermante] }

---------------

Attention, l'expression donnée
"(123 (abc"
... n'est pas valide LISP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
fn letters( requete: &mut Request, debut: usize, ajout: bool ) -> Result<usize, usize> { 
	let mut i: usize = debut; 
	let mut signes = Vec::new(); 
	let alphabet = vec![ 
		'a', 'b', 'c', 'd', 'e', 'f', 
		'g', 'h', 'i', 'j', 'k', 'l', 
		'm', 'n', 'o', 'p', 'q', 'r', 
		's', 't', 'u', 'v', 'w', 'x', 
		'y', 'z' 
	]; 
	for (y, c) in requete.chaine.chars().enumerate() { 
		if y>=debut { 
	    	if alphabet.contains( &c ) { 
				i = i+1; 
				signes.push( c ); 
	    	} else { 
	    		break; 
	    	} 
		} 
	} 
	if signes.len()>0 {
		if ajout { 
			requete.arbre.push( Atom::Lettres { 
				debut: debut, 
				fin: i, 
				contenu: signes 
			} ); 
		} 
		Result::Ok( i ) 
	} else { 
		Result::Err( debut ) 
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#!/usr/bin/sbcl --script 
 
(defvar 
	original 
	#( 
		87 139 166 249 95 
		108 185 163 62 218 
		158 164 20 210 129 
		251
	) 
) 
 
(defvar 
	matrice 
	(make-array 
		'(4 4) 
		:initial-element 0
	) 
)
 
(defun remplir-matrice-4x4 (matrice vecteur)
	(let 
		( 
			(i 0) 
		) 
		(dotimes (n 4) 
			(dotimes (m 4)
				(setf 
					(aref matrice n m) 
					(aref vecteur i) 
				) 
				(setf i (1+ i)) 
			) 
		) 
		matrice
	) 
) 
 
(defun remplir-matrice-4x4-modulo (matrice vecteur) 
	(dotimes (i 16) 
		(multiple-value-bind 
			(n m) 
			(floor i 4) 
			(setf 
				(aref matrice n m) 
				(aref vecteur i) 
			) 
		) 
	) 
	matrice 
) 
 
(print 
	(remplir-matrice-4x4 matrice original) 
) 
 
(time (dotimes (n 1000000) 
	(remplir-matrice-4x4 matrice original)
)) 
 
(print 
	(remplir-matrice-4x4-modulo matrice original) 
) 
 
(time (dotimes (n 1000000) 
	(remplir-matrice-4x4-modulo matrice original) 
))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#2A((87 139 166 249) (95 108 185 163) (62 218 158 164) (20 210 129 251)) 
Evaluation took:
  0.159 seconds of real time
  0.159265 seconds of total run time (0.159107 user, 0.000158 system)
  100.00% CPU
  351,662,692 processor cycles
  0 bytes consed 

#2A((87 139 166 249) (95 108 185 163) (62 218 158 164) (20 210 129 251)) 
Evaluation took:
  0.156 seconds of real time
  0.155932 seconds of total run time (0.155926 user, 0.000006 system)
  100.00% CPU
  344,295,288 processor cycles
  0 bytes consed

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
(define-condition coroutine-terminee (error)
	( (message :initarg :message) )
) 
 
(defmacro coroutiner-simple (corps) 
	`(let 
		( (corps ,corps) (etape nil) ) 
		(lambda () 
			(setf etape (car corps)) 
			(setf corps (cdr corps)) 
			(if (eq etape nil) 
				(error 'coroutine-terminee :message "coroutine terminée") ; inutile de continuer à renvoyer "nil" 
				(eval etape) 
			) 
		) 
	) 
) 
 
;;; Test n°1 
 
(defvar test (coroutiner-simple '( 
	(print "ok") 
	(print "ko")
))) 
 
(funcall test) ; étape 1 / affichera "ok" 
(funcall test) ; étape 2 / affichera "ko" 
(funcall test) ; étape ? / lève une erreur (la coroutine a terminée) 
 
;;; Test n°2 
 
(defvar test2 (coroutiner-simple '(
	( (print "début") (print "0") ) ; évaluation impossible (expression incorrecte) 
	(print "1") 
	(print "2")
))) ; ne fonctionnera pas 
 
;;; Test n°3 
 
(defvar test3 (coroutiner-simple '( 
	(progn (print "début") (print "0")) 
	(print "1") 
	(print "2") 
))) 
 
(funcall test3) ; étape 1 / affichera "début" puis "0" 
(funcall test3) ; étape 2 / affichera "1" 
(funcall test3) ; étape 3 / affichera "2" 
; un appel supplémentaire provoquera une erreur (la coroutine a terminée)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/usr/bin/sbcl --script 
 
(defparameter *coroutines* (make-hash-table :test 'equal)) 
 
(define-condition coroutine-terminee (error)
	( (message :initarg :message) )
) 
 
(defmacro coroutiner-simple (nom corps) 
	`(let 
		( (corps ,corps) (etape nil) (clos nil) ) 
		(setf 
			clos 
			(lambda () 
				(setf etape (car corps)) 
				(setf corps (cdr corps)) 
				(if (eq etape nil) 
					(error 
						'coroutine-terminee 
						:message "coroutine terminée"
					) 
					(progn 
						(eval etape) 
						(force-output) ; évite un arrêt du script avant l'affichage dans notre cas 
					) 
				) 
			) 
		) 
		(setf (gethash ,nom *coroutines*) clos) 
	) 
) 
 
(defun coroutine-avancer (nom) 
	(funcall (gethash nom *coroutines*)) 
) 
 
(coroutiner-simple "test" '( 
	(print "ok") 
	(print "ko")
)) 
 
(coroutine-avancer "test") ; étape 1 / afficher "ok" 
; (coroutine-avancer "test") ; étape 2 / afficher "ko"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
(coroutiner-simple "test2" '( 
	(print "début") 
	(defvar i 0)
	(print i) 
	(setf i 1) 
	(print i) 
	(print "fin") 
)) 
 
(coroutine-avancer "test2") ; "début"
(coroutine-avancer "test2") ; (rien) 
(coroutine-avancer "test2") ; 0 
(coroutine-avancer "test2") ; (rien) 
(coroutine-avancer "test2") ; "1" 
(coroutine-avancer "test2") ; "fin"

1
2
3
4
5
6
7
8
9
(defstruct triplet 
    (groupe 0) 
    (etat 0) 
    (date (get-universal-time)) 
    (poids 0) 
    (sujet "") 
    (prédicat "") 
    (objet "") 
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(in-package "SB-IMPL") 
 
(defun extraire-slots (objet) 
    (let 
        ( 
            (structuration (find-defstruct-description objet)) ; structuration de la structure 
            (slots nil) 
        ) 
        (setf slots (sb-impl::dd-slots structuration)) ; la liste ici, des slots à partir de la structuration 
        (loop for slot in slots 
            collect (dsd-name slot) ; on collecte les noms, mais nous pourrions aussi avoir le type (-type), les valeurs par défaut (-default), si le slot est en lecture seule (-read-only), etc. 
        ) 
    ) 
)

1
2
3
4
5
6
7
8
9
10
11
12
13
(defparameter 
    *triplets-attributs* 
    (extraire-slots 'triplet) 
) 
 
(defvar montriplet (make-triplet)) 
 
(loop for slot in *triplets-attributs* do 
    (format t "~s : ~s~%" 
        slot 
        (slot-value montriplet slot)
    ) 
)

1
2
3
4
5
6
7
GROUPE : 0
ETAT : 0
DATE : 3760699737
POIDS : 0
SUJET : ""
PRÉDICAT : ""
OBJET : ""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
(defun 
	additionner 
	(a b) 
	(+ a b) 
) 
 
(defun logger 
	(fct args) 
	(print "on me demande :") 
	(apply fct args) 
) 
 
(defmacro decorer (fct avec deco nom fctDeco) 
	"décorer une fonction avec une autre" 
	`(setf 
		(fdefinition ,fctDeco) 
		(lambda 
			(&rest args) 
			(funcall 
				(function ,deco) 
				(function ,fct) 
				args 
			) 
	 	) 
	) 
) 
 
(decorer 
	additionner 
avec 
	logger 
nom 
	'add_et_log 
) 
 
(print (additionner 1 2)) ; 3 
 
(print (add_et_log 3 4)) ; on me demande : 7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
[ 
	"https://www.truc.com/", 
	"https://www.truc.com", 
	"https://truc.com/", 
	"https://truc.com/truc", 
	"http://truc.fr", 
	"https://www.bidule.truc.com"
].forEach( 
	url => { 
		[tout, SSL, sousdomaine, domaine] = url.match( 
			/^http(s)?\:\/\/([a-z0-9\-\_\.]+\.)?([a-z0-9\-\_]+\.[a-z]+)/i 
		); 
		console.log( 
			url, 
			(SSL===undefined)?false:true, 
			sousdomaine, 
			domaine 
		); 
	} 
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
window.ajout = document.createElement("p"); 
window.ajout.appendChild( 
  document.createTextNode( 
    "coucou"
  )
); 
 
var observateur = new MutationObserver(
  (mutations) => {
    mutations.forEach(
      (mutation) => { 
        if (mutation.type!="childList") 
          return; 
        mutation.addedNodes.forEach(
          (element) => { 
            element.insertBefore( 
              window.ajout.cloneNode(true), 
              element.firstElementChild 
            ); 
          } 
        ); 
      } 
    ); 
  } 
);
 
observateur.observe( 
  document.querySelector('#stream-items-id'), 
  { 
  	childList: true 
  }
);
 
/*setTimeout( 
  observer.disconnect(), 
  1000000 
 ); */

1
2
3
4
5
6
7
8
<ul tabindex="-1" role="menu" aria-labelledby="menu-0" aria-hidden="false">
      <li class="copy-link-to-tweet js-actionCopyLinkToTweet" role="presentation">
        <button type="button" class="dropdown-link" role="menuitem">Copier le lien du Tweet</button>
      </li>
      <li class="embed-link js-actionEmbedTweet" data-nav="embed_tweet" role="presentation">
        <button type="button" class="dropdown-link" role="menuitem">Intégrer le Tweet</button>
      </li>
(...)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
function OuvertureSure(nom_bdd) { 
  this._log = (m) => { 
    console.log(m); 
  }; 
  this.schema_bdd = {}; 
  this.nom_bdd = nom_bdd; 
  this.version = undefined; 
  this.installer = (db) => { 
    for(var table in this.schema_bdd) { 
      this._log(`création de ${table}`); 
      db.createObjectStore(table, this.schema_bdd[table]); 
    } 
  }; 
  this.poursuivre = (db) => { 
    this._log(`tentative de poursuite`); 
    try { 
      for(var table in this.schema_bdd) { 
        db.transaction(table, "readonly"); 
      } 
      console.log("-- OK --"); 
    } catch(e) { 
      this._log( 
        `le schéma n'est pas correct ; 
         tentative de mise à jour`
      ); 
      db.close(); 
      this.version++; 
      setTimeout( 
        this.ouvrir 
      ); 
    } 
  }; 
  this.ouvrir = () => { 
    this._log(`ouverture de ${this.nom_bdd} - version ${this.version}`); 
    var r = window.indexedDB.open(this.nom_bdd, this.version); 
    r.onupgradeneeded = (evt) => { 
      this.installer(evt.target.result); 
    }; 
    r.onblocked = (evt) => { 
      this._log( 
        `Une mise à jour de la base est nécessaire 
          pour utiliser cette fonctionnalité. Vous 
          devez fermer toutes les pages ouvertes du module et redémarrer votre 
          navigateur. Si le problème persiste, vous devriez réinstaller le module.` 
      ); 
    }; 
    r.onsuccess = (evt) => { 
      this.version =  parseInt(evt.target.result.version); 
      return this.poursuivre( 
        evt.target.result
      ); 
    }; 
  } 
}; 
 
var objR = new OuvertureSure(
  "Tests"
); 
 
objR.schema_bdd = { 
  "saluts" : {} 
}; 
 
objR.ouvrir();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
function ExtraireContenuPertinent() { 
	var priorites = [ 
		[ 
			"getElementsByTagName",
			(element) => { return (element.length>0)?true:false; }
		],
		[ 
			"#id",
			(element) => { return (element!=null)?true:false; }
		],
		[ 
			"getElementsByClassName",
			(element) => { return (element.length>0)?true:false; }
		] 
	]; 
	var determinants = {
		"getElementsByTagName": ["article", "content"], 
		"#id": ["page", "blog", "story", "content", "page-root", "page_root"], 
		"getElementsByClassName": ["story", "blog", "article", "content", "contenu", "content", "page_content", "page_article", "page_root", "post"] 
	}
	var r = {}; 
	for(var fct in determinants) { 
		items = determinants[fct]; 
		r[fct] = items.map( 
			(el_cherche, index, els_cherche) => { 
				if (fct!="#id") { 
					return document.body[fct](el_cherche); 
				} else { 
					return document.getElementById(el_cherche); 
				} 
			} 
		); 
	} 
	for (var i=0; i<priorites.length; i++) { 
		var _r = r[priorites[i][0]].filter( 
			priorites[i][1] 
		); 
		if (_r.length>0) 
			return [priorites[i][0], _r]; 
	} 
	return false; 
}; 
 
var elC = ExtraireContenuPertinent(); 
if (elC!=false) 
	console.log( 
		elC
	);

1
2
3
>>> list(map(ord,list("toto va au marché"))) # ---> la fonction native de Python "ord", donne la représentation le code Unicode
[116, 111, 116, 111, 32, 118, 97, 32, 97, 117, 32, 109, 97, 114, 99, 104, 233]
{ effectuer l’opération 116 puis 111 puis 116 puis 111 puis 32 … }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def operation_A(npArray):
    return np.roll(npArray,1)  
 
def operation_B(npArray):
    return np.rot90(npArray)
 
def operation_C(npArray):
    return np.flip(npArray,1)
 
OPERATIONS = {
    "a" : operation_A,
    "b" : operation_B,
    "c" : operation_C
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
MATRICES_taille = (5,5)
MATRICES_nbre = MATRICES_taille[0] * MATRICES_taille[1] 
 
import numpy as np
 
def matrice_creer(texte_portion,ajout="*"):
    if len(texte_portion)<MATRICES_nbre:
        texte_portion = texte_portion.rjust(MATRICES_nbre, ajout)
    elif len(texte_portion)>MATRICES_nbre:
        raise ValueError(
            "la portion de texte ne peut excédent %s signes" % MATRICES_nbre
        )
    texte_portion = np.asarray(
        list(map(ord,list(texte_portion)))
    )
    texte_portion = np.reshape(
        texte_portion,
        MATRICES_taille
    )
    return texte_portion

1
2
3
4
5
6
7
8
9
10
11
12
13
def occurences_chgt_frequence(texte): # ---> « hasard » total
    return ''.join(random.choice(list(texte)) for _ in range(1))
 
def occurences_chgt_frequence(texte): # ---> le premier des signes les moins fréquents
    frequence = list(
        (
            lettre, texte.count(lettre)
        ) for lettre in list(texte)
    )
    return sorted(
        frequence,
        key = lambda couple: couple[1]
    )[0][0]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
phrase = "abcaabacaabacccaba"
 
texte_original = "Ceci est un message totalement confidentiel: \
les coordonnées du paquet de cookies sont au placard haut, \
étagère de droite. Stop."
 
ajout = occurences_chgt_frequence(
    texte_original
)
 
texte_np = matrice_creer(
    texte_original[0:20],
    ajout
)
 
for signe in phrase:
    texte_np = OPERATIONS[signe](
        texte_np
    )
 
texte_np = np.reshape(
    texte_np,
    (1, MATRICES_nbre)
)
 
print("".join(list(map(chr,texte_np.tolist()[0]))))

1
2
3
Phrase "abcaabacaabacccaba" → ****** ic*Cu t*e***ens **

Phrase "abcaabacaabaccaba" → eu t*e ic*C***** ***sn***

1
2
3
Phrase "abcaabacaabacccaba" → uot egaCttnemel tedifnos l :leiandrooc ced seéntoteuqapsukooc en tnos s icalp ud tuah dearègatéa,ord edreotS .e ise ice pt.sem n

Phrase "abcaabacaabaccaba" →  otS .e iord edrerègatéa,tuah deacalp ud tnos s ikooc en teuqapsud seéntodrooc cel :leianedifnos tnemel tot egaCt.sem nutpse ice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
 
import re 
 
class MatriceSimple:
 
    debug = False 
 
    MATRICE_taille_colonne = 8  
    OPERATIONS = {} 
 
    operations_binaires = False 
 
    def __init__(self, contenu_original, binaire=False ):
        self.contenu_original = contenu_original
        self.matriceComplexe = False
        self.operations_binaires = True if binaire is True else False 
 
    def __log__(self, *args):
        """méthode de log interne ; à surcharger"""
        if self.debug:
            print(*args)
 
    def peupler(self):
        if self.operations_binaires: 
            matriceSimple = list(
                "".join(
                    (
                        bin(ord(signe))[2:]
                    ).rjust(8,"0") for signe in self.contenu_original 
                )
            ) 
        else:
            matriceSimple = list(self.contenu_original)
        yield
        self.matriceComplexe = [
            [] 
        ] 
        y = 0 
        for bit in matriceSimple: 
            if len(self.matriceComplexe[y]) >= self.MATRICE_taille_colonne:
                self.matriceComplexe.append( 
                    [] 
                )
                y += 1 
            self.matriceComplexe[y].append( 
                bit
            )
            yield 
 
    def crypter(self, phrase, inverse=False): 
        yield from self.__matrice_transformer__(
            phrase if inverse is False else phrase[::-1],
            inverse 
        ) 
 
    def decrypter(self, phrase):
        yield from self.crypter( 
            phrase,
            True  
        ) 
 
    def __matrice_creer__(self): 
        yield
        matriceSimple = list(
            "".join(
                ( 
                    bin(ord(signe))[2:]
                ).rjust(8,"0") for signe in self.contenu_original 
            )
        ) 
        yield
        self.matriceComplexe = [
            [] 
        ] 
        y = 0 
        for bit in matriceSimple: 
            if len(self.matriceComplexe[y]) > self.MATRICES_taille[1]:
                self.matriceComplexe.append(
                    [] 
                )
                y += 1 
            self.matriceComplexe[y].append( 
                bit
            )
            yield 
 
    def __matrice_transformer__(self, phrase, inverse):
        for op_id in phrase:
            try:
                fct = getattr( 
                    self, 
                    "operation_%s" % op_id
                ) 
                self.__log__(
                    "opération '%s' demandée : %s " % (
                        op_id,
                        fct.__doc__
                    )
                )
                yield from fct( 
                    op_id, 
                    inverse 
                )
            except:
                raise ValueError("cette opération '%s' n'existe pas" % op_id) 
 
    def extraire(self):
        matrice = yield from self.__matrice_reduire__() 
        message = yield from self.__matrice_traduire__(
            matrice  
        )
        return message 
 
    def __matrice_reduire__(self): 
        if self.matriceComplexe is False:
            raise Exception( 
                "aucun contenu encore crypté"
            ) 
        bits_modifies = [] 
        for ligne in self.matriceComplexe: 
            for bit in ligne:
                bits_modifies.append(bit) 
                yield
        return bits_modifies
 
    def __matrice_traduire__(self, matriceSimple): 
        message = [] 
        if self.operations_binaires:
            for bit in re.finditer(
                "([01]{8})",
                "".join(matriceSimple)
            ): 
                    message.append(
                        chr(
                            int(
                                bit.group(0),
                                2
                            )
                        ) 
                    )
                    yield
        else:
            for signe in matriceSimple: 
                message.append(
                    signe  
                )
                yield  
        return "".join(message)
 
class CryptRapide(MatriceSimple):
 
    def operation_A(self, op_id, inverse=False):
        """décalage d'une ligne"""
        ancienne_matrice = self.matriceComplexe[:]
        yield
        if inverse:
            self.matriceComplexe = [ancienne_matrice[-1],]+ancienne_matrice[0:-1] 
        else: 
            self.matriceComplexe = ancienne_matrice[1:]+[ancienne_matrice[0],] 
 
    def operation_B(self, op_id, inverse=False):
        """décalage d'une colonne dans chaque ligne""" 
        ancienne_matrice = self.matriceComplexe[:] 
        yield
        nouvelle_matrice = [] 
        if inverse:
            for ligne in ancienne_matrice:
                ligne = ligne[:]
                nouvelle_matrice.append(
                    [ligne[-1],] + ligne[0:-1] 
                ) 
                yield
        else: 
            for ligne in ancienne_matrice:
                ligne = ligne[:]
                nouvelle_matrice.append(
                    [*ligne[1:], ligne[0]] 
                ) 
                yield
        self.matriceComplexe = nouvelle_matrice 
 
    def operation_C(self, op_id, inverse=False):
        """inversion des lignes""" 
        ancienne_matrice = self.matriceComplexe[:] 
        yield
        nouvelle_matrice = [] 
        for ligne in ancienne_matrice:
            nouvelle_matrice.append(
                ligne[::-1]
            )
            yield 
        self.matriceComplexe = nouvelle_matrice  
 
def auto(binaire, phrase_id, phrase, texte_original):
    global verrou_affichage 
    ma_matrice = CryptRapide(
        texte_original
    ) 
    ma_matrice.operations_binaires = binaire
 
    yield from ma_matrice.peupler()
    print("! log (%s) : La matrice du contenu a été créée" % phrase_id)
 
    yield from ma_matrice.crypter(
        phrase 
    ) 
    print("! log (%s) : le contenu a été crypté" % phrase_id) 
 
    valeur_message = yield from ma_matrice.extraire() 
    print("! log (%s) : message crypté :" % phrase_id, valeur_message)
 
    yield from ma_matrice.decrypter(
        phrase 
    ) 
    print("! log (%s) : message décrypté :" % phrase_id)
 
    valeur_message = yield from ma_matrice.extraire() 
    print("! log (%s) : message décrypté :" % phrase_id, valeur_message)
 
    return "Fin de la tache %s" % phrase_id 
 
def boucle_asynchrone(listes_taches):
    taches_generateurs = [] 
    for tache in listes_taches:
        fct, *args = tache 
        taches_generateurs.append(
            fct(*args)
        ) 
    while True:
        try:
            tache = taches_generateurs.pop(0)
            next(tache)
            taches_generateurs.append(
                tache
            ) 
        except StopIteration as err:
            print(">>> Le générateur a terminé et dit : ", err) 
        if len(taches_generateurs)==0:
            break 
 
if __name__=="__main__": 
 
 
    #VERSION NON-BINAIRE -> moins efficace 
    boucle_asynchrone(
        [
            (
                auto, # fct appelée dans la boucle événementielle 
                False, # ne sera pas traitement binairement 
                1, # id de la tache 
                "AAACBABCBCABACBBB", # phrase passe 
                "Ceci est un super message secret, plus long \
mais proportionnellement il y a moins de traitements, \
c'est bizarre hein ? Mais c'est comme ça, il fallait un exemple..." # contenu du message 
            ), 
            (
                auto,
                False,
                2,
                "AAACBABCBCABACBACBBCAAABBBB", 
                "Ceci est un message secret de Nothus (Julien Garderon, août 2017)." 
            ) 
        ]
    ) 
 
    print("- - - - - - - - - - - - - - -")
 
    #VERSION BINAIRE -> plus efficace (car la matrice générée est plus grande ; plus de dimensions (3, 4, ... au lieu de 2D utilisées dans cet exemple) ou une taille de phrase plus grande = plus de sécurité) 
    boucle_asynchrone(
        [
            (
                auto,
                True, 
                1,
                "AAACBABCBCABACBBB", 
                "Ceci est un super message secret, plus long \
mais proportionnellement il y a moins de traitements, \
c'est bizarre hein ? Mais c'est comme ça, il fallait un exemple..." 
            ), 
            (
                auto,
                True, 
                2,
                "AAACBABCBCABACBACBBCAAABBBB", 
                "Ceci est un message secret de Nothus (Julien Garderon, août 2017)." 
            ) 
        ]
    )

1
2
3
4
5
cond1 	|
  (+) 	|==(test)==> résultat
cond2 	|
  (+) 	|
  ... 	|

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

--- EXEMPLE 1 --- 
action1() 	|
   (+)   	|==(test)==> résultat
cond2    	|
   (+)   	|
  ...    	|

--- EXEMPLE 2 --- 
action1() 	|
   (+)    	|==( action2() )==> résultat
cond2     	|
   (+)    	|
  ...     	|

--- EXEMPLE 3 --- 
action1() 	|
   (+)    	|==( action2() )==> résultat2
resultat1 	|
   (+)    	|
  ...     	|

1
2
3
4
5
6
BIT   -->   POIDS    -->    VARIABLE
1     -->   1        -->    a
2     -->   2        -->    b
3     -->   4        -->    c
4     -->   8        -->    d
(etc)

1
2
3
4
5
BIT   -->   POIDS    -->    VARIABLE
1     -->   0        -->    a
2     -->   1        -->    b
3     -->   2        -->    c
4     -->   4        -->    d

1
2
3
VAR "A" => (0, 1, 2) 
VAR "B" => (0, 1, 3) 
VAR "C" => (0, 1, 5)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Schema: 
 
    def __init__(self):
        self.__conditions__ =  []
        self.__actions__ = {} 
 
    def condition(self, ref, params=list(), oui=3, non=2, erreur=0): # /!\ Mettre non=1 lors de l'appel pour rendre la condition optionnelle ! 
        self.__conditions__.append((
            ref,
            params,
            oui,
            non,
            erreur 
        )) 
 
    def action(self, etat, ref, params=list()):
        if isinstance(etat, int):
            etat = (etat,)
        for e in etat: 
            self.__actions__[e] = (
                ref,
                params
            ) 
 
    def essayer(self, oui=True, non=False, erreur=False):
        i = 1
        for condition in self.__conditions__:
            try:
 
                i *= self.__executer__(condition) 
            except Exception as err: 
                i *= int(
                    condition[4]() if callable(condition[4]) else condition[4]
                ) 
        try: 
            action = self.__actions__[i]
            if action[0](i, *action[1]): 
                return oui(self, i) if callable(oui) else oui 
            else: 
                return non(self,i) if callable(non) else non 
        except:
            return erreur(self,i) if callable(erreur) else erreur
 
    def __executer__(self,condition):
        if condition[0].__class__ is self.__class__:
            condition = list(condition) 
            condition[0] = condition[0].essayer
        return (
            condition[2]() if callable(condition[2]) else condition[2] 
        ) if condition[0](*condition[1]) is True else (
            condition[3]() if callable(condition[3]) else condition[3]
        )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
from time import gmtime, strftime
 
def Calendrier(jours = { # Si la valeur d'aujourd'hui est sur False, le retour de la condition sera à 2 (non par défaut) ou sinon 3 (oui par défaut) 
    0: False, 
    1: False, 
    2: True, 
    3: True, 
    4: True, 
    5: True, 
    6: True
}):
    print("Calendrier : ", jours[int(strftime("%w", gmtime()))]) 
    return jours[int(strftime("%w", gmtime()))]
 
def Rien(i, echo=None): 
    print("---\ni =", i, "\n", type(echo), echo,"\n---") 
    return True  
 
if __name__=="__main__": 
 
    Sequence1 = ifttt.Schema() 
 
    Sequence1.condition(
        Calendrier 
    ) 
    Sequence1.action( 
        0, 
        Rien,
        ("Oups ! (1)",) 
    ) 
    Sequence1.action( 
        (2, 3), 
        Rien,
        ("Une première étape de franchie !",) 
    ) 
 
    Sequence2 = ifttt.Schema() 
 
    Sequence2.condition(
        Sequence1 
    ) 
    Sequence2.action( 
        0, 
        Rien,
        ("Oups ! (2)",) 
    ) 
    Sequence2.action( 
        (2,3), 
        Rien,
        ("La seconde étape tant attendue...",) 
    ) 
 
    Sequence2.essayer()