progge.rs
1.0.0
Proggers adalah taman bermain analisis program untuk bahasa yang sederhana dan penting.
Ketergantungan:
Baik Elina maupun LLVM maupun Z3 tidak diperlukan untuk memeriksa jenis dan visualisasi CFG, karenanya mereka dapat diubah menjadi fitur peti. Tolong, jangan ragu untuk berkontribusi!
Setelah prasyarat diinstal, Anda dapat menginstal proggers dengan: cargo install --git https://github.com/skius/progge.rs
proggers
<sourcefile> # the sourcefile to analyze
--cfg # visualize the control flow graph
--typecheck # type-check the source
--analyze # shorthand for --symex --ai
--symex # run symbolic execution
--ai # run abstract interpretation
--ast # print the abstract syntax tree
-o <outputfile> # compile source into the executable <outputfile>
--verbose # print LLVM IR when compiling
Proggers dapat menganalisis program yang ditulis dalam bahasa progge.
program: funcdef*
funcdef: fn var((var: type,)*) -> type { block }
block: stmt;*
stmt: let var = expr
| var = expr
| expr[expr] = expr
| var(expr,*)
| testcase!
| unreachable!
| if expr { block } [ else { block } ]
| while expr { block }
| return [expr]
expr: var
| int
| bool
| expr binop expr
| unop expr
| var(expr,*)
| [expr,*]
| [expr; expr]
binop: + | - | * | / | % | < | <= | > | >= | == | !=
unop: - | !
var: [A-Za-z_][A-Za-z0-9_]*
type: int | bool | [type]
Tidak ada yang istimewa. Binding yang diizinkan dibayarkan untuk membayangi binding sebelumnya.
Built-in Progge khusus dan bagian mana dari proggers memanfaatkannya:
| Bawaan | Keterangan | Ai | Se | Tc | C |
|---|---|---|---|---|---|
unreachable! | Menegaskan bahwa aliran kontrol mungkin tidak akan pernah mencapai pernyataan ini | [X] | [X] | ||
testcase! | Menginstruksikan generasi testcases yang mencapai pernyataan ini | [X] | [X] | ||
assume!(expr) | Mengasumsikan ekspresi bool yang diberikan sebagai benar | [X] | [X] | ||
analyze!(expr) | Menginstruksikan analisis numerik untuk mencetak penampilan berlebihan dari ekspresi int | [X] | |||
int_arg(expr) | Mengembalikan argumen baris perintah expr-th dikonversi ke int int | [X] | [X] | ||
print_int(expr) | Mencetak int yang diberikan ke stdout | [X] |
Legenda : TC: Jenis Pemeriksaan, SE: Eksekusi Simbolik, AI: Interpertasi Abstrak, C: Kompilasi
Proggers dapat menganalisis program di bawah ini dan menemukan nilai pengembalian yang mungkin, seperti yang dapat dilihat dari kanan bawah " z: [-1,0] " yang menunjukkan z mungkin -1 atau 0 .
fn analyze ( x : int , y : int ) -> int {
if x < y {
while x < y {
x = x + 1 ;
y = y - 1 ;
}
let z = y - x ;
return z ;
}
return - 2 ;
} 
Proggers juga mendukung beberapa arahan yang memanfaatkan hasil interpretasi abstrak.
menganalisa! : Secara eksplisit mencetak nilai yang mungkin untuk ekspresi yang diberikan. Misalnya, menjalankan proggers --typecheck --analyze analyzer-examples/analyze_loop.progge memberikan umpan balik berikut (gambar tidak menunjukkan output lengkap):
Perhatikan bahwa nilai-nilai yang dikembalikan untuk ekspresi adalah aproksimasi berlebihan .
unreachable! : Menegaskan bahwa pernyataan tidak dapat dijangkau. Misalnya, menjalankan proggers --typecheck --analyze analyzer-examples/unreachable.progge memberikan umpan balik berikut:
Perhatikan bahwa sekali lagi, analisis yang tidak dapat dijangkau menggunakan interpretasi abstrak menghitung aproksimasi berlebihan - yaitu itu mungkin memberikan positif palsu (memperingatkan tentang pernyataan yang tidak dapat unreachable! unreachable! Lihat eksekusi simbolik untuk pernyataan yang dijamin tentang jangkauan.
Interpretasi Abstrak (Wikipedia) menghitung aproksimasi berlebihan, yang berarti bahwa semua perilaku program yang mungkin (mungkin lebih, tetapi tidak kurang) ditangkap olehnya, yaitu implikasinya adalah "jika program yang sebenarnya menunjukkan perilaku, maka perilaku tersebut terkandung dalam penerapan interpretasi abstrak yang berlebihan".
Singkatnya, interpretasi abstrak dapat membuktikan tidak adanya perilaku program yang tidak diinginkan, yang mungkin misalnya pengecualian indeks-out-of-bounds (TODO), pelaksanaan unreachable! pernyataan, atau panggilan fungsi yang argumennya tidak memenuhi prasyarat fungsi.
Testcase! : Menghasilkan testcases (yaitu nilai argumen untuk fungsi) yang mencapai pernyataan. Misalnya, menjalankan proggers --typecheck --symex analyzer-examples/symex_arr_hard.progge memberi:
Catatan: Pembuatan testcase juga berfungsi untuk panggilan ke int_arg - lihat symex_blackbox.progge
analyzer-examples/symex_arr_hard.progge:7:13: sample inputs reaching this statement:
{ x = 1, y = 0 }
{ x = 0, y = 1 }
{ x = 0, y = 2 }
{ x = 2, y = 1 }
{ x = 1, y = 2 }
unreachable! : Selanjutnya, jika diberikan unreachable! sebenarnya tidak dapat dijangkau, eksekusi simbolis akan melempar kesalahan dan memberikan input sampel yang mencapai pernyataan. Misalnya, menjalankan proggers --typecheck --symex analyzer-examples/unreachable.progge memberi: 
Eksekusi simbolik (Wikipedia) menghitung suatu penekanan di bawah, yang berarti implikasinya adalah "jika eksekusi simbolik melaporkan jalur (set nilai input), maka program nyata juga harus mengikuti jalur itu".
Singkatnya, eksekusi simbolik dapat membuktikan kemampuan mencapai pernyataan dengan memberikan input contoh konkret, atau, dengan kata lain, ia dapat membuktikan adanya perilaku program tertentu.
let lingkup bayangan/leksikal: Proggers memperhatikan bahwa ada lima variabel berbeda yang disebut x , seperti yang dapat dilihat di ast yang dibersihkan yang dikembalikan oleh proggers:
// Original source code
fn analyze ( x : int ) -> int {
x = 0 ;
let x_2 = 10 ;
let x = x ;
let x = x + 1 ;
x_2 = 5 ;
if true {
let x = 2 ;
x = 3 ;
} else {
let x = 4 ;
}
// returns 1
return x ;
}
// Type-checked AST
fn analyze ( x_1 : int ) {
x_1 = 0 ;
let x_2_1 = 10 ;
let x_2 = x_1 ;
let x_3 = ( x_2 + 1 ) ;
x_2_1 = 5 ;
if true {
let x_4 = 2 ;
x_4 = 3 ;
} else {
let x_5 = 4 ;
}
return x_3 ;
}Selanjutnya, Proggers dapat memberikan pesan kesalahan yang bagus (terima kasih kepada Ariadne):
// Source
fn foo ( ) -> int {
return true ;
} 
Lihat analyzer-examples/tc_bad untuk lebih banyak contoh.
Proggers dapat menyusun program ke kode asli.
$ proggers codegen-examples/factorial.progge -t -o factorial
$ ./factorial 4
24
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24Berlisensi di bawah salah satu dari
di pilihan Anda.
Kecuali jika Anda secara eksplisit menyatakan sebaliknya, kontribusi apa pun secara sengaja diserahkan untuk dimasukkan dalam pekerjaan oleh Anda, sebagaimana didefinisikan dalam lisensi APACHE-2.0, harus dilisensikan ganda seperti di atas, tanpa syarat atau ketentuan tambahan.
