Jenis-jenis penterjemah. Bilangan negeri LR(1) untuk tatabahasa yang boleh dikatakan menarik juga agak besar. Tatabahasa sedemikian jarang mempunyai sifat LR(0). Dalam amalan, kaedah perantaraan antara LR(0) dan LR(1), dikenali sebagai LALR(1), lebih kerap digunakan.

Penterjemah biasanya juga mendiagnosis ralat, menyusun kamus pengecam, menghasilkan teks program untuk pencetakan, dsb.

Siaran program- transformasi program yang dibentangkan dalam salah satu bahasa pengaturcaraan ke dalam program dalam bahasa lain dan, dalam erti kata tertentu, bersamaan dengan yang pertama.

Bahasa di mana program input dibentangkan dipanggil bahasa asal, dan program itu sendiri - kod sumber. Bahasa keluaran dipanggil Bahasa sasaran atau kod objek.

Konsep terjemahan digunakan bukan sahaja untuk bahasa pengaturcaraan, tetapi juga untuk bahasa komputer lain, seperti bahasa markup, serupa dengan HTML, dan bahasa semula jadi, seperti bahasa Inggeris atau Rusia. Walau bagaimanapun, artikel ini hanya mengenai bahasa pengaturcaraan; untuk bahasa semula jadi, lihat: Terjemahan.

Jenis-jenis penterjemah

Alamat. Peranti berfungsi, yang menukar alamat maya (Alamat maya) kepada alamat memori sebenar (Alamat memori).
Dialog. Menyediakan penggunaan bahasa pengaturcaraan dalam mod perkongsian masa.
Berbilang pas. Membentuk modul objek atas beberapa paparan program sumber.
belakang. Sama seperti penerjemah. Lihat juga: decompiler, disassembler.
Pas tunggal. Membentuk modul objek dalam satu paparan berurutan program sumber.
Mengoptimumkan. Melakukan pengoptimuman kod dalam modul objek yang dijana.
Berorientasikan sintaksis (didorong sintaksis). Menerima sebagai input penerangan tentang sintaks dan semantik bahasa dan teks dalam bahasa yang diterangkan, yang diterjemahkan mengikut huraian yang diberikan.
Ujian. Satu set makro bahasa himpunan yang membolehkan anda menetapkan pelbagai prosedur penyahpepijatan dalam program yang ditulis dalam bahasa himpunan.

Perlaksanaan

Tujuan terjemahan adalah untuk menukar teks daripada satu bahasa kepada bahasa lain, yang boleh difahami oleh penerima teks. Dalam kes program penterjemah, penerima ialah peranti teknikal (pemproses) atau program penterjemah.

Terdapat beberapa contoh lain di mana seni bina siri komputer yang dibangunkan adalah berdasarkan atau sangat bergantung pada beberapa model struktur program. Oleh itu, siri GE/Honeywell Multics adalah berdasarkan model semantik pelaksanaan program yang ditulis dalam bahasa PL/1. Dalam Templat:Tidak diterjemahkan B5500, B6700 ... B7800 adalah berdasarkan model program masa jalan yang ditulis dalam bahasa ALGOL lanjutan. ...

Pemproses i432, seperti seni bina terdahulu ini, juga berdasarkan model semantik struktur program. Walau bagaimanapun, tidak seperti pendahulunya, i432 tidak berdasarkan model bahasa pengaturcaraan tertentu. Sebaliknya, matlamat utama pembangun adalah untuk menyediakan sokongan masa jalan langsung untuk kedua-duanya data abstrak(iaitu, pengaturcaraan dengan jenis data abstrak), dan untuk sistem pengendalian khusus domain. …

Kelebihan pengkompil: program disusun sekali dan tiada transformasi tambahan diperlukan setiap kali ia dilaksanakan. Sehubungan itu, pengkompil tidak diperlukan pada mesin sasaran yang mana program disusun. Kelemahan: Langkah kompilasi yang berasingan melambatkan penulisan dan penyahpepijatan dan menyukarkan untuk menjalankan program kecil, ringkas atau sekali sahaja.

Jika bahasa sumber ialah bahasa himpunan (bahasa peringkat rendah yang hampir dengan bahasa mesin), maka pengkompil bahasa sedemikian dipanggil penghimpun.

Kaedah pelaksanaan yang bertentangan ialah apabila program dilaksanakan menggunakan jurubahasa tiada siaran langsung. Jurubahasa memprogramkan mesin yang kitaran pelaksanaan pengambilan berfungsi dengan arahan dalam bahasa tahap tinggi, dan bukan dengan arahan mesin. ini pemodelan perisian mencipta mesin maya yang melaksanakan bahasa. Pendekatan ini dipanggil tafsiran murni. Tafsiran tulen biasanya digunakan untuk bahasa dengan struktur mudah (contohnya, APL atau Lisp). Jurubahasa baris perintah memproses arahan dalam skrip dalam UNIX atau dalam fail kelompok (.bat) dalam MS-DOS, juga biasanya dalam mod tafsiran tulen.

Kelebihan jurubahasa tulen: ketiadaan tindakan perantaraan untuk terjemahan memudahkan pelaksanaan jurubahasa dan menjadikannya lebih mudah untuk digunakan, termasuk dalam mod dialog. Kelemahannya ialah jurubahasa mesti hadir pada mesin sasaran di mana program itu akan dilaksanakan. Dan harta jurubahasa tulen, bahawa ralat dalam atur cara yang ditafsirkan dikesan hanya apabila percubaan dibuat untuk melaksanakan arahan (atau baris) dengan ralat, boleh dianggap sebagai kelemahan dan kelebihan.

Terdapat kompromi antara kompilasi dan tafsiran tulen dalam pelaksanaan bahasa pengaturcaraan, apabila jurubahasa, sebelum melaksanakan program, menterjemahkannya ke dalam bahasa perantaraan (contohnya, ke dalam bytecode atau p-code), lebih mudah untuk tafsiran (iaitu, kita bercakap tentang jurubahasa dengan penterjemah terbina dalam) . Kaedah ini dipanggil pelaksanaan bercampur. Contoh pelaksanaan bahasa campuran ialah Perl. Pendekatan ini menggabungkan kedua-dua kelebihan penyusun dan jurubahasa (kelajuan pelaksanaan yang lebih tinggi dan kemudahan penggunaan) dan keburukan (terjemahan dan penyimpanan program dalam bahasa perantaraan memerlukan sumber tambahan; Jurubahasa mesti hadir untuk melaksanakan program pada mesin sasaran.) Juga, seperti pengkompil, pelaksanaan bercampur memerlukannya sebelum melaksanakan sumber tidak mengandungi kesalahan (leksikal, sintaksis dan semantik).

Dengan peningkatan dalam sumber komputer dan pengembangan rangkaian heterogen (termasuk Internet) yang menghubungkan komputer dari jenis dan seni bina yang berbeza, jenis tafsiran baharu telah muncul, di mana kod sumber (atau perantaraan) disusun menjadi kod mesin secara langsung pada masa jalan , "dengan cepat." Bahagian kod yang telah dikompilasi dicache supaya apabila ia diakses semula, ia serta-merta menerima kawalan, tanpa penyusunan semula. Pendekatan ini dipanggil kompilasi dinamik.

Kelebihan kompilasi dinamik ialah kelajuan tafsiran program menjadi setanding dengan kelajuan pelaksanaan program dalam bahasa yang disusun konvensional, manakala program itu sendiri disimpan dan diedarkan dalam satu bentuk, bebas daripada platform sasaran. Kelemahannya ialah kerumitan pelaksanaan yang lebih besar dan keperluan sumber yang lebih besar daripada dalam kes penyusun ringkas atau jurubahasa tulen.

Kaedah ini berfungsi dengan baik untuk

Hantar kerja baik anda di pangkalan pengetahuan adalah mudah. Gunakan borang di bawah

Pelajar, pelajar siswazah, saintis muda yang menggunakan pangkalan pengetahuan dalam pengajian dan kerja mereka akan sangat berterima kasih kepada anda.

Disiarkan di http://www.allbest.ru

pengenalan

1.1 Analisis atas ke bawah

1.2 Analisis bawah ke atas

1.2.1 LR(k) - tatabahasa

1.2.1.1 LR(0) - tatabahasa

1.2.2 LALR(1) - tatabahasa

2. Pembangunan penterjemah

2.1 Analisis keperluan

2.2 Reka bentuk

2.2.1 Mereka bentuk penganalisis leksikal

2.2.4 Pelaksanaan perisian parser

2.3 Pengekodan

2.4 Pengujian

Kesimpulan

Senarai sumber yang digunakan

Lampiran A. Penyenaraian teks program penterjemah

Lampiran B. Keputusan ujian

Lampiran B. Gambarajah atur cara penterjemah

pengenalan

Sudah lama berlalu, sebelum menulis program, anda perlu memahami dan mengingati berpuluh-puluh arahan mesin. Pengaturcara moden merumuskan tugasnya dalam bahasa pengaturcaraan peringkat tinggi dan menggunakan bahasa himpunan hanya dalam kes yang luar biasa. Seperti yang diketahui, bahasa algoritma menjadi tersedia kepada pengaturcara hanya selepas penciptaan penterjemah dari bahasa ini.

Bahasa pengaturcaraan agak berbeza antara satu sama lain dalam tujuan, struktur, kerumitan semantik, dan kaedah pelaksanaan. Ini mengenakan ciri khususnya sendiri pada pembangunan penterjemah tertentu.

Bahasa pengaturcaraan adalah alat untuk menyelesaikan masalah dalam bidang subjek yang berbeza, yang menentukan spesifik organisasi mereka dan perbezaan tujuan. Contohnya termasuk bahasa seperti Fortran, yang berorientasikan kepada pengiraan saintifik, C, yang bertujuan untuk pengaturcaraan sistem, Prolog, yang menerangkan masalah inferens dengan berkesan, dan Lisp, yang digunakan untuk pemprosesan senarai rekursif. Contoh-contoh ini boleh diteruskan. Setiap bidang subjek meletakkan keperluannya sendiri pada organisasi bahasa itu sendiri. Oleh itu, kita boleh perhatikan pelbagai bentuk perwakilan pengendali dan ungkapan, perbezaan dalam set operasi asas, pengurangan kecekapan pengaturcaraan apabila menyelesaikan masalah yang tidak berkaitan dengan bidang subjek. Perbezaan linguistik juga tercermin dalam struktur penterjemah. Lisp dan Prolog paling kerap dilaksanakan dalam mod tafsiran kerana fakta bahawa ia menggunakan penjanaan dinamik jenis data semasa pengiraan. Penterjemah Fortran dicirikan oleh pengoptimuman agresif kod mesin yang terhasil, yang menjadi mungkin disebabkan oleh semantik binaan bahasa yang agak mudah - khususnya, kerana ketiadaan mekanisme untuk penamaan alternatif pembolehubah melalui penunjuk atau rujukan. Kehadiran penunjuk dalam bahasa C mengenakan keperluan khusus pada pengedaran dinamik ingatan.

Struktur bahasa mencirikan hubungan hierarki antara konsepnya, yang digambarkan oleh peraturan sintaksis. Bahasa pengaturcaraan boleh sangat berbeza antara satu sama lain dalam organisasi konsep individu dan hubungan antara mereka. Bahasa pengaturcaraan PL/1 membenarkan prosedur dan fungsi sarang sewenang-wenangnya, manakala dalam C semua fungsi mesti berada pada tahap sarang luar. Bahasa C++ membenarkan pembolehubah ditakrifkan pada mana-mana titik dalam program sebelum penggunaan pertamanya, dan dalam pembolehubah Pascal mesti ditakrifkan dalam kawasan khas penerangan. Mengambil ini lebih jauh ialah PL/1, yang membenarkan pembolehubah diisytiharkan selepas ia digunakan. Atau anda boleh meninggalkan penerangan sama sekali dan menggunakan peraturan lalai. Bergantung pada keputusan yang dibuat, penterjemah boleh menganalisis program dalam satu atau beberapa pas, yang mempengaruhi kelajuan terjemahan.

Semantik bahasa pengaturcaraan berbeza secara meluas. Mereka berbeza bukan sahaja dalam ciri pelaksanaan operasi individu, tetapi juga dalam paradigma pengaturcaraan, yang menentukan perbezaan asas dalam kaedah pembangunan program. Spesifik pelaksanaan operasi mungkin melibatkan kedua-dua struktur data yang sedang diproses dan peraturan untuk memproses jenis data yang sama. Bahasa seperti PL/1 dan APL menyokong operasi matriks dan vektor. Kebanyakan bahasa berfungsi terutamanya dengan skalar, menyediakan prosedur dan fungsi yang ditulis oleh pengaturcara untuk memproses tatasusunan. Tetapi walaupun semasa menjalankan operasi menambah dua integer, bahasa seperti C dan Pascal boleh berkelakuan berbeza.

Bersama-sama dengan pengaturcaraan prosedur tradisional, juga dipanggil imperatif, terdapat paradigma seperti pengaturcaraan berfungsi, pengaturcaraan logik dan pengaturcaraan berorientasikan objek. Struktur konsep dan objek bahasa sangat bergantung pada paradigma yang dipilih, yang juga mempengaruhi pelaksanaan penterjemah.

Malah bahasa yang sama boleh dilaksanakan dalam beberapa cara. Ini disebabkan oleh fakta bahawa teori tatabahasa formal membenarkan pelbagai kaedah menghuraikan ayat yang sama. Selaras dengan ini, penterjemah boleh memperoleh hasil yang sama (program objek) daripada teks sumber asal dengan cara yang berbeza.

Pada masa yang sama, semua bahasa pengaturcaraan mempunyai beberapa ciri umum dan parameter. Kesamaan ini juga menentukan prinsip penyusunan penterjemah yang serupa untuk semua bahasa.

Bahasa pengaturcaraan direka untuk memudahkan pengaturcaraan. Oleh itu, pengendali dan struktur data mereka lebih berkuasa daripada dalam bahasa mesin.

Untuk meningkatkan keterlihatan program, bukannya kod angka, representasi simbolik atau grafik bagi binaan bahasa digunakan, yang lebih mudah untuk persepsi manusia.

Untuk mana-mana bahasa ia ditakrifkan:

- banyak simbol yang boleh digunakan untuk menulis atur cara yang betul (abjad), elemen asas,

- banyak program yang betul (sintaks),

- "makna" setiap program yang betul (semantik).

Tanpa mengira spesifik bahasa, mana-mana penterjemah boleh dianggap sebagai penukar berfungsi F, menyediakan pemetaan unik dari X ke Y, di mana X ialah atur cara dalam bahasa sumber, Y ialah atur cara dalam bahasa output. Oleh itu, proses terjemahan itu sendiri boleh diwakili secara formal dengan agak ringkas dan jelas: Y = F(X).

Secara formal, masing-masing program yang betul X ialah rentetan aksara daripada beberapa abjad A, ditukar kepada rentetan Y yang sepadan, terdiri daripada aksara daripada abjad B.

Bahasa pengaturcaraan seperti mana-mana sistem yang kompleks, ditakrifkan melalui hierarki konsep yang mentakrifkan hubungan antara unsur-unsurnya. Konsep-konsep ini saling berkaitan mengikut peraturan sintaksis. Setiap program yang dibina mengikut peraturan ini mempunyai struktur hierarki yang sepadan.

Dalam hal ini, ciri umum berikut boleh dibezakan tambahan untuk semua bahasa dan programnya: setiap bahasa mesti mengandungi peraturan yang membenarkan menjana program yang sepadan dengan bahasa ini atau mengiktiraf surat-menyurat antara program bertulis dan bahasa tertentu.

Satu lagi ciri ciri semua bahasa ialah semantik mereka. Ia menentukan maksud operasi bahasa dan ketepatan operan. Rantaian yang mempunyai struktur sintaksis yang sama dalam bahasa pengaturcaraan yang berbeza mungkin berbeza dalam semantik (yang, sebagai contoh, diperhatikan dalam C++, Pascal, Basic). Pengetahuan tentang semantik bahasa membolehkan anda memisahkannya daripada sintaksnya dan menggunakannya untuk penukaran kepada bahasa lain (untuk menjana kod).

Tujuan kerja kursus ini adalah untuk membangunkan penterjemah pendidikan daripada yang dipermudahkan bahasa teks tahap tinggi.

1. Kaedah analisis tatabahasa

Mari kita lihat kaedah asas penghuraian tatabahasa.

1.1 Analisis atas ke bawah

Apabila menghuraikan dari atas ke bawah, petunjuk perantaraan bergerak di sepanjang pokok mengikut arah dari akar ke daun. Dalam kes ini, apabila melihat rantai dari kiri ke kanan, kesimpulan tangan kiri secara semula jadi akan diperolehi. Dalam penghuraian deterministik, masalahnya ialah peraturan yang akan digunakan untuk menyelesaikan bukan terminal paling kiri.

1.1.1 LL(k) - bahasa dan tatabahasa

Pertimbangkan pokok inferens dalam proses mendapatkan keluaran kiri rantai. Rantai perantaraan dalam proses inferens terdiri daripada rantaian terminal w, paling kiri bukan terminal A, bahagian bawah inferens x:

-S--

/ \

/ -A-x-\

/ | \

-w---u----

Rajah 1

Untuk meneruskan penghuraian, adalah perlu untuk menggantikan bukan terminal A mengikut salah satu peraturan borang A:y. Jika anda mahu penghuraian bersifat deterministik (tiada pulangan), peraturan ini perlu dipilih dengan cara yang istimewa. Tatabahasa dikatakan mempunyai sifat LL(k) jika, untuk memilih peraturan, adalah memadai untuk mempertimbangkan hanya wAx dan aksara k pertama bagi rentetan u yang tidak diperiksa. Huruf pertama L (Kiri) merujuk kepada melihat rantai input dari kiri ke kanan, yang kedua merujuk kepada output kiri yang digunakan.

Mari kita tentukan dua set rantai:

a) FIRST(x) ialah set rentetan terminal yang diterbitkan daripada x, dipendekkan kepada k aksara.

b) FOLLOW(A) - satu set rantai terminal dipendekkan kepada aksara k, yang boleh mengikuti A dengan segera dalam rantai output.

Tatabahasa mempunyai sifat LL(k) jika, daripada kewujudan dua rantai inferens kiri:

S:: wAx: wzx:: wu

S:: wAx: wtx:: wv

daripada keadaan FIRST(u)=FIRST(v) ia mengikuti z=t.

Dalam kes k=1, untuk memilih peraturan untuk A, cukup untuk mengetahui hanya bukan terminal A dan a - aksara pertama rantai u:

- peraturan A:x harus dipilih jika a disertakan dalam FIRST(x),

- peraturan A:e hendaklah dipilih jika a disertakan dalam FOLLOW(A).

Sifat LL(k) mengenakan sekatan yang agak kuat pada tatabahasa. Contohnya, tatabahasa LL(2) S: aS | a tidak mempunyai harta LL(1), kerana PERTAMA(aS)=PERTAMA(a)=a. Dalam kes ini, anda boleh mengurangkan nilai k menggunakan "pemfaktoran" (mengambil faktor daripada kurungan):

S: aA

A: S | e

Mana-mana LL(k)-tatabahasa adalah jelas. Tatabahasa rekursif kiri tidak tergolong dalam kelas LL(k) untuk mana-mana k. Kadangkala adalah mungkin untuk menukar tatabahasa bukan LL(1) kepada tatabahasa LL(1) yang setara dengan menghapuskan rekursi kiri dan pemfaktoran. Walau bagaimanapun, masalah kewujudan tatabahasa LL(k)-setara untuk tatabahasa bukan LL(k)-sewenang-wenangnya tidak dapat diputuskan.

1.1.2 Kaedah penurunan rekursif

Kaedah turunan rekursif ditujukan kepada kes apabila pengkompil diprogramkan dalam salah satu bahasa peringkat tinggi, apabila penggunaan prosedur rekursif dibenarkan.

Idea utama keturunan rekursif ialah setiap nonterminal tatabahasa mempunyai prosedur yang sepadan yang mengiktiraf mana-mana rantai yang dihasilkan oleh bukan terminal ini. Prosedur ini memanggil satu sama lain apabila diperlukan.

Keturunan rekursif boleh digunakan untuk mana-mana tatabahasa LL(1). Setiap bukan terminal tatabahasa mempunyai prosedur yang sepadan, yang bermula dengan peralihan kepada label yang dikira dan mengandungi kod yang sepadan dengan setiap peraturan untuk bukan terminal ini. Bagi simbol input yang tergolong dalam set pemilihan peraturan tertentu, peralihan yang dikira memindahkan kawalan kepada kod yang sepadan dengan peraturan itu. Untuk simbol input yang tinggal, kawalan dipindahkan ke prosedur pengendalian ralat.

Kod mana-mana peraturan mengandungi operasi untuk setiap aksara yang disertakan dalam sebelah kanan peraturan. Operasi disusun mengikut susunan simbol muncul dalam peraturan. Berikutan operasi terakhir, kod tersebut mengandungi pulangan daripada prosedur.

Menggunakan turunan rekursif dalam bahasa peringkat tinggi menjadikan pengaturcaraan dan penyahpepijatan lebih mudah.

1.2 Analisis bawah ke atas

Mari kita pertimbangkan penghuraian bawah ke atas, di mana pin perantaraan digerakkan di sepanjang pokok ke arah akar. Jika anda membaca aksara dalam rentetan dari kiri ke kanan, pokok parse akan kelihatan seperti ini:

-S--

/ \

/-x-\

/ | \

--w--b--u-

Rajah 2

Output perantaraan mempunyai bentuk xbu, di mana x ialah rantaian terminal dan bukan terminal, dari mana bahagian rantai terminal w yang dilihat adalah output, bu ialah bahagian rantai terminal yang tidak dilihat, b ialah simbol seterusnya. Untuk meneruskan analisis, anda boleh sama ada menambah aksara b pada bahagian rantai yang dilihat (lakukan apa yang dipanggil "anjakan"), atau pilih di hujung x rantaian z (x=yz) yang satu daripada peraturan tatabahasa B:z boleh digunakan pada z dan menggantikan x kepada rantai yB (melakukan apa yang dipanggil "konvolusi"):

-S-- -S--

/ \ / \

/-x-b-\ /yB-\

/ | \ / | \

--w--b--u- --w--b--u-

Rajah 3 - Selepas syif Rajah 4 - Selepas lilitan

Jika lilitan digunakan hanya untuk aksara terakhir x, maka kami akan menerima output rantaian yang betul. Penghuraian ini dipanggil LR, di mana simbol L (Kiri, kiri) merujuk kepada melihat rantai dari kiri ke kanan, dan R (Kanan, kanan) merujuk kepada output yang terhasil.

Urutan operasi anjakan dan lipatan adalah penting. Oleh itu, penghuraian deterministik memerlukan pemilihan antara anjakan dan lilitan (dan peraturan lilitan yang berbeza) pada setiap saat.

1.2.1 LR(k) - tatabahasa

Jika, dalam proses penghuraian LR, adalah mungkin untuk membuat keputusan yang menentukan tentang peralihan/pengurangan, dengan mengambil kira hanya rentetan x dan aksara k pertama bahagian ghaib rentetan input u (aksara k ini dipanggil rentetan lanjutan ), tatabahasa dikatakan mempunyai sifat LR(k).

-S--

/ \

/-x-\

--w----u--

Rajah 5

Perbezaan antara tatabahasa LL(k) dan LR(k) dari segi pokok inferens:

-S-

/ | \

/A\

/ / \ \

-w---v---u-

Rajah 6

Dalam kes LL(k)-tatabahasa, peraturan yang digunakan untuk A boleh ditentukan secara unik oleh w dan k pertama aksara vu, dan dalam kes LR(k)-tatabahasa, oleh w,v dan k pertama watak-watak awak. Penaakulan yang tidak ketat ini menunjukkan bahawa LL(k)-bahasa< LR(k)-языки (при k > 0).

1.2.1.1 LR(0) - tatabahasa

Mari kita pertimbangkan terlebih dahulu tatabahasa yang paling mudah bagi kelas ini - LR(0). Apabila menghuraikan rentetan dalam bahasa LR(0), anda tidak perlu menggunakan rantai lanjutan sama sekali - pilihan antara anjakan dan lipatan dibuat berdasarkan rantai x. Oleh kerana semasa menghuraikan ia hanya berubah dari hujung kanan, ia dipanggil tindanan. Mari kita anggap bahawa tiada simbol yang tidak berguna dalam tatabahasa dan simbol awal tidak muncul di sebelah kanan peraturan - kemudian konvolusi kepada simbol awal menandakan kejayaan menyelesaikan penghuraian. Mari cuba huraikan set rangkaian terminal dan bukan terminal yang muncul pada tindanan semasa semua penghuraian LR (dengan kata lain, semua inferens sebelah kanan daripada tatabahasa).

Mari kita tentukan set berikut:

L(A:v) - konteks kiri peraturan A:v - set keadaan tindanan serta-merta sebelum v dilipat menjadi A semasa semua penghuraian LR berjaya. Jelas sekali, setiap rantai dalam L(A:v) berakhir dengan v. Jika ekor v semua rantai tersebut terputus, maka kita mendapat set rantai yang berlaku di sebelah kiri A semasa semua inferens tangan kanan yang berjaya. Mari kita nyatakan set ini sebagai L(A) - konteks kiri bagi bukan terminal A.

Mari kita bina tatabahasa untuk set L(A). Terminal tatabahasa baharu akan menjadi terminal dan bukan terminal tatabahasa asal; bukan terminal tatabahasa baharu akan dilambangkan dengan ,... - nilai mereka akan menjadi konteks kiri bukan terminal tatabahasa asal. Jika S ialah watak awal tatabahasa asal, maka tatabahasa konteks kiri akan mengandungi peraturan : e - konteks kiri S mengandungi rantai kosong Untuk setiap peraturan tatabahasa asal, contohnya, A: B C d E

dan tambah peraturan pada tatabahasa baharu:

: - L(B) termasuk L(A)

: B - L(C) termasuk L(A) B

: B C d - L(E) termasuk L(A) B C d

Tatabahasa yang terhasil mempunyai jenis khas(tatabahasa sedemikian dipanggil linear kiri), oleh itu, set konteks kiri

- biasa. Ia berikutan bahawa sama ada rentetan tergolong dalam konteks kiri bukan terminal boleh dikira secara induktif menggunakan mesin keadaan terhingga, mengimbas rentetan dari kiri ke kanan. Mari kita huraikan proses ini secara membina.

Mari kita panggil LR(0)-situasi peraturan tatabahasa dengan satu kedudukan bertanda antara simbol sebelah kanan peraturan. Contohnya, untuk tatabahasa S:A; A:aAA; A:b LR(0)-situasi berikut wujud: S:_A; S:A_; A:_aAA; A:a_AA; A:aA_A; A:aAA_; A:_b; A:b_. (kedudukan ditunjukkan dengan garis bawah).

Kami akan mengatakan bahawa rantai x adalah konsisten dengan situasi A:b_c jika x=ab dan a kepunyaan L(A). (Dengan kata lain, output LR boleh diteruskan x_... = ab_...:: abc_...:: aA_...:: S_.) Dalam istilah ini, L(A:b) ialah set rentetan yang konsisten dengan situasi A:b_, L(A)

- rantaian selaras dengan situasi A:_b, untuk sebarang peraturan A:b.

Biarkan V(u) ialah set situasi yang konsisten dengan u. Mari kita tunjukkan bahawa fungsi V ialah induktif.

Jika set V(u) termasuk situasi A:b_cd, maka situasi A:bc_d tergolong dalam V(uc). (c - terminal atau bukan terminal; b, d - jujukan (mungkin kosong) terminal dan bukan terminal). Tiada situasi lain dalam bentuk A:b_d, dengan b tidak kosong dalam V(uc). Ia kekal untuk menambah situasi dalam bentuk C:_... kepada V(uc), untuk setiap bukan terminal C yang konteks kirinya mengandungi uc. Jika situasi A:..._C... (C-nonterminal) tergolong dalam set V(uc), maka uc tergolong dalam L(C) dan V(uc) termasuk situasi dalam bentuk C:_... untuk semua C- peraturan tatabahasa.

V(e) mengandungi situasi S:_... (watak permulaan S), serta situasi A:_... jika bukan terminal A berlaku serta-merta selepas _ dalam situasi yang telah dimasukkan dalam V(e).

Akhir sekali, kami bersedia untuk mentakrifkan tatabahasa LR(0). Biarkan u menjadi kandungan tindanan semasa penghuraian LR, dan V(u) ialah set situasi LR(0) yang selaras dengan u. Jika V(u) mengandungi situasi dalam bentuk A:x_ (jujukan x bagi terminal dan bukan terminal), maka u tergolong dalam L(A:x) dan lilitan x menjadi A dibenarkan. Jika V(u ) mengandungi situasi A:..._a.. (a-terminal), maka syif dibenarkan. Konflik anjakan-konvolusi dikatakan wujud jika kedua-dua anjakan dan lilitan dibenarkan untuk rentetan u yang sama. Konvolusi pengurangan-konvolusi dikatakan wujud jika konvolusi mengikut peraturan yang berbeza dibenarkan.

Tatabahasa dipanggil LR(0) jika tiada konflik anjakan-kurangkan atau lipatan-kurangkan untuk semua keadaan tindanan semasa inferens LR.

1.2.1.2 LR(k) - tatabahasa

Hanya keadaan tindanan digunakan untuk memutuskan antara peralihan dan lipatan dalam penghuraian LR(0). Penghuraian LR(k) juga mengambil kira aksara k pertama bagi bahagian rantaian input yang tidak kelihatan (yang dipanggil rantaian awal). Untuk mewajarkan kaedah, anda harus mengulangi alasan perenggan sebelumnya dengan teliti, membuat perubahan pada takrifan.

Kami juga akan memasukkan rantaian awal dalam konteks kiri peraturan. Jika output yang betul menggunakan output wAu: wvu, maka pasangan wv,FIRSTk(u) adalah milik Lk(A:v), dan pasangan w,FIRSTk(u) adalah milik Lk(A). Set konteks kiri, seperti dalam kes LR(0), boleh dikira menggunakan aruhan pada rantai kiri. Mari kita panggil LR(k)-situasi sebagai pasangan: peraturan tatabahasa dengan kedudukan yang ditanda dan rantai maju yang panjangnya tidak lebih daripada k. Kami akan memisahkan peraturan daripada rantaian pendahuluan dengan garis menegak.

Kami akan mengatakan bahawa rantai x konsisten dengan situasi A:b_c|t jika terdapat LR-output: x_yz = ab_yz:: abc_z:: aA_z:: S_, dan FIRSTk(z) = t. Peraturan untuk mengira secara induktif set keadaan Vk adalah seperti berikut:

Vk(e) mengandungi situasi S:_a|e untuk semua peraturan S:a, dengan S ialah aksara permulaan. Bagi setiap situasi A:_Ba|u daripada Vk(e), setiap peraturan B:b dan rantai x kepunyaan FIRSTk(au), adalah perlu untuk menambah situasi B:_b|x kepada Vk(e).

Jika Vк(w) termasuk situasi A:b_cd|u, maka situasi A:bc_d|u akan menjadi milik Vk(wc). Bagi setiap situasi A:b_Cd|u daripada Vk(wc), setiap peraturan C:f dan rantai x kepunyaan FIRSTk(du) adalah perlu untuk menambah situasi C:_f|x kepada Vk(wc).

Kami menggunakan set keadaan LR(k) yang dibina untuk menyelesaikan isu anjakan-konvolusi. Biarkan anda menjadi kandungan tindanan dan x menjadi rantai atas. Jelas sekali, lilitan mengikut peraturan A:b boleh dijalankan jika Vk(u) mengandungi situasi A:b_|x. Memutuskan sama ada peralihan dibenarkan memerlukan berhati-hati jika tatabahasa mengandungi e-peraturan. Dalam situasi A:b_c|t (c tidak kosong), anjakan adalah mungkin jika c bermula dari terminal dan x milik FIRSTk(ct). Secara tidak rasmi, anda boleh menolak simbol paling kiri di sebelah kanan peraturan ke tindanan, menyediakan lilitan seterusnya. Jika c bermula dengan nonterminal (keadaan kelihatan seperti A:b_Cd|t), kemudian menolak simbol ke dalam tindanan sebagai persediaan untuk konvolusi ke dalam C adalah mungkin hanya jika C tidak menghasilkan rantai kosong. Contohnya, dalam keadaan V(e)= S:_A|e; A:_AaAb|e,a, A:_|e,a tiada anjakan yang dibenarkan, kerana Apabila memperoleh rantai terminal daripada A, pada beberapa langkah ia diperlukan untuk menggunakan peraturan A:e kepada bukan terminal A yang terletak di hujung kiri rantai.

Mari kita takrifkan set EFFk(x), yang terdiri daripada semua elemen set FIRSTk(x), semasa terbitan yang mana bukan terminal di hujung kiri x (jika ada) tidak digantikan dengan rantai kosong. Dalam istilah ini, anjakan dibenarkan jika dalam set Vk(u) terdapat situasi A:b_c|t, c tidak kosong dan x milik EFFk(ct).

Tatabahasa dipanggil LR(k)-tatabahasa jika tiada keadaan LR(k) mengandungi dua situasi A:b_|u dan B:c_d|v supaya u tergolong dalam EFFk(dv). Pasangan sedemikian sepadan dengan konflik lipatan lipatan jika d kosong, dan konflik lipatan anjakan jika d tidak kosong.

Dalam praktiknya, tatabahasa LR(k) tidak digunakan untuk k>1. Terdapat dua sebab untuk ini. Pertama: sangat nombor besar LR(k) menyatakan. Kedua: untuk mana-mana bahasa yang ditakrifkan oleh LR(k)-tatabahasa, terdapat LR(1)-tatabahasa; Selain itu, untuk mana-mana bahasa KS yang menentukan terdapat tatabahasa LR(1).

Bilangan negeri LR(1) untuk tatabahasa yang boleh dikatakan menarik juga agak besar. Tatabahasa sedemikian jarang mempunyai sifat LR(0). Dalam amalan, kaedah perantaraan antara LR(0) dan LR(1), dikenali sebagai LALR(1), lebih kerap digunakan.

1.2.2 LALR(1) - tatabahasa

Kedua-dua kaedah ini adalah berdasarkan idea yang sama. Mari kita bina satu set kanonik LR(0)-keadaan tatabahasa. Jika set ini tidak mengandungi konflik, maka parser LR(0) boleh digunakan. Jika tidak, kami akan cuba menyelesaikan konflik yang timbul dengan mempertimbangkan rantaian pendahuluan satu aksara. Dalam erti kata lain, mari kita cuba membina parser LR(1) dengan banyak keadaan LR(0).

Kaedah LALR(1) (Pandang Ke Hadapan) adalah seperti berikut. Mari kita perkenalkan hubungan kesetaraan pada set LR(1)-situasi: kita akan mempertimbangkan dua situasi sebagai setara jika ia berbeza hanya dalam rantai utamanya. Sebagai contoh, situasi A:Aa_Ab|e dan A:Aa_Ab|a adalah setara. Mari kita bina set kanonik bagi keadaan LR(1) dan gabungkan keadaan yang terdiri daripada satu set situasi setara.

Jika set keadaan yang terhasil tidak mengandungi konflik LR(1), dan oleh itu membenarkan pembinaan penghurai LR(1), maka tatabahasa tersebut dikatakan mempunyai sifat LALR(1).

2. Pembangunan penterjemah

2.1 Analisis keperluan

Di dalam ini kerja kursus adalah perlu untuk membangunkan penterjemah pendidikan dalam bentuk jurubahasa daripada bahasa yang ditakrifkan oleh tatabahasa formal yang sepadan. Terdapat empat peringkat utama dalam membangunkan jurubahasa:

Mereka bentuk penganalisis leksikal;

Reka bentuk mesin layan diri;

Pelaksanaan perisian parser;

Pembangunan modul tafsiran.

Pembangunan akan dijalankan menggunakan bilik bedah sistem Windows XP pada PC IBM dengan pemproses Intel Pentium IV.

Berdasarkan trend pembangunan perisian, bahasa pengaturcaraan C# dalam persekitaran Visual Studio 2010 telah dipilih untuk melaksanakan penterjemah pendidikan.

2.2 Reka bentuk

2.1.1 Mereka bentuk penganalisis leksikal

Leksikal analisis melibatkan mengimbas program terjemahan (sumber) dan mengenal leksem yang membentuk ayat teks sumber. Token termasuk, khususnya, kata kunci, tanda operasi, pengecam, pemalar, aksara khas, dsb.

Hasil kerja penganalisis leksikal (pengimbas) ialah urutan token, dengan setiap token biasanya diwakili oleh beberapa kod panjang tetap (contohnya, integer), serta penjanaan mesej tentang ralat sintaksis (leksikal). , jika ada. Jika token itu, sebagai contoh, kata kunci, maka kodnya memberikan semua maklumat yang diperlukan. Dalam kes, sebagai contoh, pengecam, nama pengecam yang diiktiraf juga diperlukan, yang biasanya direkodkan dalam jadual pengecam, teratur, sebagai peraturan, menggunakan senarai. Jadual yang serupa diperlukan untuk pemalar.

Leksem boleh diterangkan oleh dua ciri utama. Salah satunya ialah sama ada leksem itu tergolong dalam kelas tertentu (pembolehubah, pemalar, operasi, dll.) Atribut kedua menentukan unsur tertentu daripada kelas ini.

Bentuk khusus jadual simbol (struktur data) tidak penting kepada lexer atau parser. Kedua-duanya hanya perlu menyediakan keupayaan untuk mendapatkan indeks yang mengenal pasti secara unik, contohnya, pembolehubah yang diberikan dan mengembalikan nilai indeks untuk menambah maklumat tentang nama pembolehubah yang diberikan dalam jadual simbol.

Melihat jadual ID melaksanakan dua fungsi utama:

a) merekodkan nama baharu dalam jadual semasa memproses perihalan pembolehubah;

b) mencari nama yang pernah direkodkan dalam jadual.

Ini membolehkan anda mengenal pasti situasi yang salah seperti berbilang perihalan pembolehubah dan kehadiran pembolehubah yang tidak diterangkan.

Pembangunan penganalisis leksikal terdiri daripada sebahagian daripada pemodelan automata yang berbeza untuk mengecam pengecam, pemalar, perkataan terpelihara, dsb. Jika token jenis berbeza bermula dengan aksara yang sama atau urutan aksara yang sama, mungkin perlu menggabungkan pengecamannya.

Dengan menjalankan penganalisis leksikal, kami memecahkan program kami kepada token, selepas itu setiap token melepasi semakan panjang (token tidak boleh lebih daripada 11 aksara). Setelah berjaya menyelesaikan peringkat ini, kami menyemak lokasi token yang betul (kata kunci var, mula, tamat, untuk, untuk, buat, akhir_untuk). Kemudian kami menganalisis leksem pembolehubah - ia tidak sepatutnya mengandungi nombor dalam perihalannya dan tidak boleh diulang. Pada peringkat terakhir, kami menyemak ejaan leksem yang betul ( kata kunci, pengecam yang tidak diketahui). Jika sekurang-kurangnya satu daripada semakan gagal, penganalisis leksikal mencetak ralat.

Gambar rajah program penganalisis leksikal ditunjukkan dalam Lampiran B dalam Rajah B.1.

2.2.2 Reka bentuk mesin layan diri

Mari kita takrifkan tatabahasa berikut:

G: (Vt, Va, I, R),

di mana Vt ialah set simbol terminal, Va ialah set simbol bukan terminal, I ialah keadaan awal tatabahasa, R ialah set peraturan tatabahasa.

Untuk tatabahasa ini, kami mentakrifkan set simbol terminal dan bukan terminal:

Mari kita susun peraturan untuk tatabahasa G kita dan bentangkannya dalam Jadual 1.

Jadual 1 - Peraturan tatabahasa

Peraturan No.	Bahagian kiri peraturan	Bahagian kanan peraturan








		f ID = EX t EX d LE n;













Sambungan jadual 1.
Peraturan No.	Bahagian kiri peraturan	Bahagian kanan peraturan

Penamaan leksem, terjemahan leksem kepada kod dan senarai sebutan tatabahasa masing-masing diberikan dalam jadual 2, 3, 4.

Jadual 2 - Penamaan leksem

	Penamaan token
	kata kunci "bermula" (permulaan perihalan tindakan)
	kata kunci "tamat" (hujung huraian tindakan)
	kata kunci "var" (huraian pembolehubah)
	kata kunci "baca" (operator input data)
	kata kunci "tulis" (operator output data)
	kata kunci "untuk" (penyataan gelung)
	kata kunci "kepada"
	kata kunci "buat"
	kata kunci "end_case" (akhir penyataan gelung)
	jenis pembolehubah "integer"
	operasi tambah
	operasi tolak
	operasi darab
	aksara pemisah ":"
	aksara pemisah ";"
	aksara pemisah "("
	watak pemisah ")"
	watak pemisah ","
	Penamaan token
	aksara pemisah "="

Jadual 3 - Terjemahan leksem kepada kod












<цифра>
<буква>

Jadual 4 - Senarai simbol tatabahasa

Jawatan	Penjelasan
	Program
	Penerangan pengiraan
	Penerangan Pembolehubah
	Senarai pembolehubah
	Operator
	Tugasan
	Ungkapan
	Subungkapan
	Operasi binari
	Operasi unary
	Senarai tugasan
	Pengecam
	berterusan

Mari kita bina pengecam bawah ke atas yang menentukan.

Pertimbangkan hubungan berikut untuk membina pengecam bawah ke atas yang menentukan:

a) Jika terdapat simbol kumpulan B sehingga beberapa peraturan tatabahasa termasuk rantai AB dan terdapat simbol xPERTAMA"(B), maka kita akan menganggap bahawa hubungan x SELEPAS A ditentukan antara simbol x dan A

b) Jika dalam tatabahasa tertentu terdapat peraturan B -> bAb A, BV a, b maka hubungan A COVER x ditentukan antara A dan x.

Semua tatabahasa kita tetap sama, iaitu:

G: (Vt, Va, I, R),

dan peraturan tatabahasa G diberikan dalam Jadual 5.

Jadual 5 - Peraturan tatabahasa

Peraturan No.	Bahagian kiri peraturan	Bahagian kanan peraturan








		f ID = EX t EX d LE n;?














Sambungan jadual 5.
Peraturan No.	Bahagian kiri peraturan	Bahagian kanan peraturan

di mana? - penanda untuk hujung rantai.

Mari kita tentukan beberapa kes:

a) ID terdiri daripada banyak huruf abjad Latin, iaitu, kita akan menganggap bahawa u = ( 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)

b) Pemalar CO terdiri daripada nombor, iaitu, kita akan menganggap bahawa k = (0,1,2,3,4,5,6,7,8,9)

Untuk tatabahasa kami menjadi strategi keutamaan bercampur, syarat berikut mesti dipenuhi:

a) Kekurangan e-peraturan

b) Adakah terdapat peraturan di bawahnya, x SELEPAS A? A VERT x = ?

c) A -> olehYg

dan adalah perlu bahawa DALAM SELEPAS x? B VERT x = ?

iaitu, dalam tatabahasa mereka akan dilaksanakan DALAM SELEPAS x atau A SELEPAS x, di mana x ialah simbol predikat bagi rantai b.

a) PERTAMA"(PG)=(PG?)

PERTAMA"(RG) = PERTAMA(DE) = (RG, v,:, i,;)

PERTAMA" (AL) = PERTAMA (b LE e)= (AL, b, e)

PERTAMA" (DE) = PERTAMA (v LV: i;) = (DE, v,:, i,;)

PERTAMA" (LV) = PERTAMA (ID, LV) = (LV, ID)

PERTAMA" (OP) =(OP, ID, CO)

PERTAMA" (EQ) = PERTAMA(ID = EX;) = (EQ, =,;)

PERTAMA" (EX) = (EX, SB, -)

PERTAMA" (BO) =(B0, +,*,-)

PERTAMA" (SB) = PERTAMA((EX)SB) ? PERTAMA(OP) ? PERTAMA(BO)=(SB, (,), OP, BO);

PERTAMA" (LE) = PERTAMA(EQ) = (LE, (,), =,;, f, t, d, n, w, r)

PERTAMA" (UO) = (UO,-)

PERTAMA" (ID)= PERTAMA" (u) = (u)

PERTAMA" (CO) = PERTAMA" (k) = (k)PERTAMA" (e) =( e)

PERTAMA" (b) =( b)

PERTAMA" (e) =( e)

PERTAMA" (v) =( v)

PERTAMA" (w) =( w)

PERTAMA" (r) =( r)

PERTAMA" (i) =( i)

PERTAMA" (f) =( f)

PERTAMA" (d) =(d)

PERTAMA" (n) =( n)

PERTAMA" (c) =( c)

PERTAMA" (+) =( +)

PERTAMA" (*) =( *)

PERTAMA" (-) =( -)

PERTAMA" (,) =(,)

PERTAMA" (;) =(;)

PERTAMA" (:) =(:)

PERTAMA" (=) = ( = )

PERTAMA" (() =( ()

PERTAMA" ()) =() )

PERTAMA" (u) =(u)

PERTAMA" (k) =(k)

b) JEJAK `(AL) = (?)? JEJAK"(PG)=(?,b,e)

SETERUSNYA ` (DE) = (?)?PERTAMA"(AL)= (?, b, e)

SETERUSNYA ` (LV) = (?)?PERTAMA"(:)= (?,:)

SETERUSNYA ` (OP) = (?)?PERTAMA"(SB)= (?,;,), d, t, +, -, *)

JEJAK ` (EQ) = (?)?PERTAMA"(LE)=(?, (,),;, f, =, t, d, n,w,r )

JEJAK ` (EX) = (?)? PERTAMA"(t)? PERTAMA"(d)? PERTAMA"(;)? PERTAMA"())=(?, t,d,;,))

SETERUSNYA ` (BO) = (?)?PERTAMA"(SB)= (?, (,), OP, BO)

SETERUSNYA ` (UO) = (?)?PERTAMA"(SB)= (?, (,), OP, BO)

TRACE ` (SB) = (?)? TRACE"(EX)= (?, t,d,;,), +, *, -)

JEJAK ` (LE) = (?) ?PERTAMA"(e) ?PERTAMA"(n) = (?, e, n)

JEJAK `(ID)= (?)? SETERUSNYA" (OP) ? PERTAMA" (=) =(?,;,), d, t, +, -, *, =)

JEJAK `(CO) = (?)? TRACE" (OP)= (?,;,), d, t, +, -, *, =)

SETERUSNYA ` (b) =(?)?PERTAMA"(LE)= (?, u, =,;)

JEJAK ` (e) =(?)? JEJAK"(AL)= (?, b)

SETERUSNYA ` (v) =(?)?PERTAMA"(LV)= (?, u)

SETERUSNYA ` (w) =(?)?PERTAMA"(()= (?, ()

SETERUSNYA ` (r) =(?)?PERTAMA"(() = (?, ()

SETERUSNYA ` (i) =(?)?PERTAMA"(;)= (?,; )

SETERUSNYA ` (f) =(?)?PERTAMA"(ID) = (?, u)

SETERUSNYA ` (d) =(?)?PERTAMA"(LE)= (?, u, =,;)

SETERUSNYA ` (n) =(?)?PERTAMA"(i) = (?, i )

JEJAK ` (+) =(?)? JEJAK"(DALAM) = (?, +,*,-)

JEJAK ` (-) =(?)? JEJAK"(DALAM) = (?, +,*,-)

JEJAK ` (*) =(?)? JEJAK"(DALAM) = (?, +,*,-)

TRACK ` (;) =(?)? TRACK" (DE)? TRACK `(LE1)? TRACK" (EQ) = (?, b, e, l, u)

SETERUSNYA ` (:) =(?)?PERTAMA"(i)= (?, i )

SETERUSNYA ` (=) = (?)?PERTAMA"(EX) = (? (,), u, k, +, -, *)

SETERUSNYA ` (() =(?)?PERTAMA"(DE)= (?, v,:, i,;)

JEJAK ` ()) =(?)? PERTAMA"(;) = (?,; )

JEJAK ` (,) =(?)? PERTAMA"(LV) = (?, u)

JEJAK `(u) =(?)? PERTAMA" (ID)= ( u, ?)

JEJAK `(k) =(?)? PERTAMA (CO)= (?, k)

c) PG ->DE AL

AL SELEPAS DE = (b,e) SELEPAS DE = ((b DE), (e DE) )

e SELEPAS LE = ((e LE))

LE SELEPAS b = ((,), =,;, f, t, d, n, w, r) SELEPAS b = (((b), ()b), (=b), (;b), ( f b), (t b), (d b), (n b), (w b), (r b))

;SELEPAS i = ((; i))

i SELEPAS: = ( (i:) )

: SELEPAS LV = ( (: LV) )

LV SELEPAS v = ( (ID, v) )

LV SELEPAS, = ((ID,))

SELEPAS ID = ((,u))

LE SELEPAS EQ = ((,), =,;, f, t, d, n, w, r ) SELEPAS EQ = (((EQ), () EQ), (= EQ), (; EQ), ( f EQ), (t EQ), (d EQ), (n EQ), (w EQ), (r EQ))

LE -> r (DE);

; SELEPAS) = ((;)))

) SELEPAS DE = (((DE))

DE SELEPAS (= (= ((v)), (:)), (i)), (;)), (e)))

(SELEPAS r = (((r))

LE -> w (DE);

; SELEPAS) = ((;)))

) DE TERAKHIR = (((DE))

DE SELEPAS (= ((v)), (:)), (i)), (;)), (e)))

(SELEPAS w = (((w)))

LE -> f ID = EX t EX d LE n;

; SELEPAS n = ((;n))

n SELEPAS LE = ( (n, LE))

LE SELEPAS d = ( ((,), =,;, f, t, d, n, w, r)) ? SELEPAS d = (((d), ()d), (;d), (f d), (t d), (d d), (n d), (w d), (r d))

d SELEPAS EX = ((d, EX))

EX SELEPAS t = (BO, -) ? SELEPAS t = ((BO t), (- t))

t SELEPAS EX = ( t EX)

EX SELEPAS = = ((BO, -) ? SELEPAS = = ((BO =), (- =))

SELEPAS ID = ((= ID))

ID SELEPAS f = ((ID f))

EQ -> ID = EX;

; SELEPAS EX = ((; EX )

EX SELEPAS = = (BO, -) ? SELEPAS = = ((BO =), (- =))

SELEPAS u = ( (=u))

SB SELEPAS UO = ( (,), OP, BO ) SELEPAS UO = (((UO), (OP UO), (BO UO) )

) SELEPAS EX = ( ()EX) )

EX SELEPAS (= (BO, -) ? SELEPAS (= ((BO (), (- ()))

SB->SB BO SB

SB SELEPAS BO = ((,), OP, BO) SELEPAS BO = (((BO), ()BO), (OP BO), (BO BO))

BO SELEPAS SB = (+,*,-) SELEPAS SB = ((+SB), (*SB), (-SB))

ID SELEPAS u = ((u, u))

G) PG ->DE AL

AL COLLECTION PG = AL COLLECTION TRACE" (PG) = ((AL ?))

e KOLEKSI AL = e KOLEKSI SURAK"(AL)= ((eb), (e?))

=; TRACK KOLEKSI"(DE) = ((;b), (;?))

LV COLLECTION LV = LV COLLECTION TRAIL" (LV) = ((LV:), (LV?))

ID COLLECTION LV = ID COLLECTION TRACK" (LV) = ((ID:), (ID ?))

; RUNTUH LE =; TREK KOLEKSI" (LE) = ((; e), (;?), (; n))

LE -> f ID = EX t EX d LE n;

; RUNTUH LE =; TREK KOLEKSI" (LE) = ((; e), (;?), (; n))

EQ COLLECTION LE = EQ COVER TRACE" (LE) = ((EQ e), (EQ?), (EQ n))

EQ -> ID = EX;

; RUNTUH EQ =; TRACK KOLEKSI" (EQ) = ((; (), (;)), (;;), (;f), (;?), (;=), (;t), (;d), (; n), (;w), (;r))

SB COLLECTION EX = SB COVER TRACE" (EX) = ((SB t), (SB?), (SB d), (SB)), (SB;), (SB(), (SB=), (SBf ), (SBn), (SBw), (SBr) )

) KOLEKSI SB = SB KOLEKSI TRACE" (SB) = (() t), ()?), () d), ())), ();))

OP COLLECTION SB = OP COLLECTION TRACE" (SB) = ((OP t), (OP ?), (OP d), (OP)), (OP;))

SB->SB BO SB

SB KOLEKSI SB = SB COVER TRACE" (SB) = ((SB, t), (SBd), (SB;). (SB)), (SB+), (SB-), (SB*), (SB? ) }

KOLEKSI UO = - TRACK KOLEKSI" (UO) = ( (-?), (--))

COLLECTION BO = + COLLECTION TRACK" (BO) = ((++), (+?), (+*), (+-))

* COLLECTION BO = * COLLECTION TRACK" (BO) = ((*+), (*?), (**), (*-))

KOLEKSI BO = - TRACK KOLEKSI" (BO) = ((-+), (-?), (-*), (--))

ID COLLECTION OP = ID COVERAGE TRACE" (OP) = ((ID+), (ID?), (ID*), (ID-))

COVER OP = COVER TRACE" (OP) = ((CO+), (CO?), (CO*), (CO-), (CO;), (COd), (COt), (CO)))

ID KOLEKSI ID = ID KOLEKSI TRACK" (ID) = ((ID)), (ID ?), (ID k), (ID+), (ID-), (ID*), (ID=), (IDt) , (IDd)))

u ID KOLEKSI = l TRACK KOLEKSI" (ID) = ((u)), (u?), (uk), (u+), (u-), (u*), (u=), (ut), (ud)))

CO COVER CO = COVER TRACE" (CO) = (CO+), (CO?), (CO*), (CO-), (CO;), (COd), (COt), (CO)))

k COLLECTION CO = k COLLECTION TRACE" (CO) = (k+), (k?), (k*), (k-), (k;), (kd), (kt), (k)))

Satu dijumpai situasi konflik apabila meruntuhkan peraturan

OP ->ID dan ID -> u ID

Kami memasukkan ID1 -> ID, oleh itu kami menulis semula peraturan ID1 -> ID u

Oleh itu, kami akan melakukan operasi lilitan.

ID KOLEKSI ID1 = TRACK KOLEKSI ID1" (ID) = ((ID1)), (ID1 ?), (ID1 k), (ID1+), (ID1-), (ID1*), (ID1=), (ID1t) , (ID1d)))

Bagi setiap pasangan (x, A)? x SELEPAS A kita membina fungsi peralihan yang menentukan tindakan pemindahan??(S 0 , x, A) = (S 0 , A)

? (S0, b, DE) = (S0, DEb)

? (S0, e, DE) = (S0, DEe)

? (S0, e, LE) = (S0, LEe)

? (S0,), b) = (S0, b))

? (S0,;, b) = (S0, b;)

? (S0, (, b) = (S0, b()

? (S0, =, b) = (S0, b=)

? (S0, f, b) = (S0, bf)

? (S0, t, b) = (S0, bt)

? (S0, d, b) = (S0, bd)

? (S0, n, b) = (S0, bn)

? (S0, w, b) = (S0, bw)

? (S0, r, b) = (S0, br)

? (S0,;, i) = (S0, i;)

? (S0, i, :) = (S0, i :)

? (S0,:LV) = (S0,LV:)

? (S0, ID, v) = (S0, vID)

? (S0,ID,) = (S0,ID)

? (S0, u) = (S0, u,)

? (S0, (, EQ)= (S0, EQ()

? (S0,), EQ)= (S0, EQ))

? (S0, =, EQ)= (S0, EQ=)

? (S0,;, EQ)= (S0, EQ;)

? (S0, f, EQ)= (S0, EQf)

? (S0, t, EQ)= (S0, EQt)

? (S0, d, EQ)= (S0, EQd)

? (S0, n, EQ)= (S0, EQn)

? (S0, w, EQ)= (S0, EQw)

? (S0, r, EQ)= (S0, EQr)

? (S0,;,)) = (S0,);)

? (S0, (, DE) = (S0, DE()

? (S0, v,)) = (S0,)v)

? (S0,;,)) = (S0,);)

? (S0, i,)) = (S0,)i)

? (S0,:,)) = (S0,):)

? (S0, e,)) = (S0,)e)

? (S0, (, r) = (S0, r()

? (S0, (, w) = (S0, w()

? (S0,;, n) = (S0, n;)

? (S0, n, LE) = (S0, LEn)

? (S0, (, d) = (S0, d()

? (S0,), d) = (S0, d))

? (S0,;, d) = (S0, d;)

? (S0, f, d) = (S0, df)

? (S0, t, d) = (S0, dt)

? (S0, d, d) = (S0, dd)

? (S0, n, d) = (S0, dn)

? (S0, w, d) = (S0, dw)

? (S0, r, d) = (S0, dr)

? (S0, d, EX) = (S0, EXd)

? (S0, BO, t) = (S0, tBO)

? (S0, -, t) = (S0, t-)

? (S0, t, EX) = (S0, EXt)

? (S0, BO, =) = (S0, =BO)

? (S0, -, =) = (S0, =-)

? (S0, =, ID) = (S0, ID=)

? (S0, ID, f) = (S0, fID)

? (S0,;, EX) = (S0, EX;)

? (S0, =, u) = (S0, u=)

? (S0, (, UO) = (S0, UO()

? (S0, OP, UO) = (S0, UO OP)

? (S0, BO, UO) = (S0, UO BO)

? (S0,), EX) = (S0, EX))

? (S0, BO, () = (S0, (BO)

? (S0, BO, -) = (S0, -BO)

? (S0, (, BO) = (S0, BO()

? (S0,),BO) = (S0,)BO)

? (S0, OP, BO) = (S0, BOOP)

? (S0, +, SB) = (S0, SB+)

? (S0, *, SB) = (S0, SB*)

? (S0, -, SB) = (S0, SB-)

? (S0, u, u) = (S0, uu)

Bagi setiap pasangan (x, A)? Dan CONVERT x kita bina fungsi peralihan yang menentukan tindakan konvolusi?? * (S 0 , x, bA) = (S 0 , B), dengan B->bA

? * (S 0 , AL, ?) = (S 0 , PG)

? * (S 0 , e, b) = (S 0 , AL)

? * (S 0 , n, ?) = (S 0 , AL)

? * (S 0 ,;, b) = (S 0 , DE)

? * (S 0 ,;, ?) = (S 0 , DE)

? * (S 0 ,;, e) = (S 0 , DE)

? * (S 0 , LV,:) = (S 0 , LV)

? * (S 0 , LV, ?) = (S 0 , LV)

? * (S 0 , ID, ?) = (S 0 , LV)

? * (S 0 , ID, e) = (S 0 , LV)

? * (S 0 ,;, e) = (S 0 , LE)

? * (S 0 ,;, ?) = (S 0 , LE)

? * (S 0 ,;, n) = (S 0 , LE)

? * (S 0 , EQ, n) = (S 0 , LE)

? * (S 0 , EQ, e) = (S 0 , LE)

? * (S 0 , EQ, ?) = (S 0 , LE)

? * (S 0 ,;, e) = (S 0 , LE)

? * (S 0 ,;, ?) = (S 0 , LE)

? * (S 0 ,;, () = (S 0 , EQ)

? * (S 0 ,;,)) = (S 0 , EQ)

? * (S 0 ,;, f) = (S 0 , EQ)

? * (S 0 ,;, =) = (S 0 , EQ)

? * (S 0 ,;, t) = (S 0 , EQ)

? * (S 0 ,;, d) = (S 0 , EQ)

? * (S 0 ,;, n) = (S 0 , EQ)

? * (S 0 ,;, w) = (S 0 , EQ)

? * (S 0 ,;, r) = (S 0 , EQ)

? * (S 0 , SB, ?) = (S 0 , EX)

? * (S 0 , SB, d) = (S 0 , EX)

? * (S 0 , SB,)) = (S 0 , EX)

? * (S 0 , SB,;) = (S 0 , EX)

? * (S 0 , SB, w) = (S 0 , EX)

? * (S 0 , SB, r) = (S 0 , EX)

? * (S 0 , SB, f) = (S 0 , EX)

? * (S 0 , SB, =) = (S 0 , EX)

? * (S 0 , SB, t) = (S 0 , EX)

? * (S 0 , SB, ?) = (S 0 , SB)

? * (S 0 , SB, () = (S 0 , SB)

? * (S 0 , SB,)) = (S 0 , SB)

? * (S 0 , SB, u) = (S 0 , SB)

? * (S 0 , SB, k) = (S 0 , SB)

? * (S 0 , SB, +) = (S 0 , SB)

? * (S 0 , SB, -) = (S 0 , SB)

? * (S 0 , SB, *) = (S 0 , SB)

? * (S 0 , SB, e) = (S 0 , SB)

? * (S 0 ,), t) = (S 0 , SB)

? * (S 0 ,), ?) = (S 0 , SB)

? * (S 0 ,), t) = (S 0 , SB)

(S 0 ,),)) = (S 0 , SB)

? * (S 0 ,),;) = (S 0 , SB)

? * (S 0 , -, ?) = (S 0 , UO)

? * (S 0 , -, -) = (S 0 , UO)

? * (S 0 , +, +) = (S 0 , BO)

? * (S 0 , +, ?) = (S 0 , BO)

? * (S 0 , +, *) = (S 0 , BO)

? * (S 0 , -, +) = (S 0 , BO)

? * (S 0 , -, ?) = (S 0 , BO)

? * (S 0 , -, *) = (S 0 , BO)

? * (S 0 , -, -)) = (S 0 , BO)

? * (S 0 , *, +) = (S 0 , BO)

? * (S 0 , *, ?) = (S 0 , BO)

? * (S 0 , *, *) = (S 0 , BO)

? * (S 0 , *, -)) = (S 0 , BO)

? * (S 0 , u, +) = (S 0 , BO)

? * (S 0 , u, ?)= (S 0 , BO)

? * (S 0 , u, *) = (S 0 , BO)

? * (S 0 , u, -)) = (S 0 , BO)

? * (S 0 , k, +) = (S 0 , BO)

? * (S 0 , k, ?) = (S 0 , BO)

? * (S 0 , k, *) = (S 0 , BO)

? * (S 0 , k, -)) = (S 0 , BO)

? * (S 0 , CO, ?) = (S 0 , OP)

? * (S 0 , CO, +) = (S 0 , OP)

? * (S 0 , CO, *) = (S 0 , OP)

? * (S 0 , CO, -) = (S 0 , OP)

? * (S 0 , CO,;) = (S 0 , OP)

? * (S 0 , CO, d) = (S 0 , OP)

? * (S 0 , CO, t) = (S 0 , OP)

? * (S 0 , ID, -) = (S 0 , OP)

? * (S 0 , ID, *) = (S 0 , OP)

? * (S 0 , ID, ?) = (S 0 , OP)

? * (S 0 , ID, () = (S 0 , OP)

? * (S 0 , ID,)) = (S 0 , OP)

? * (S 0 , ID, u) = (S 0 , OP)

? * (S 0 , ID, k) = (S 0 , OP)

? * (S 0 , ID, -) = (S 0 , OP)

? * (S 0 , ID, +) = (S 0 , OP)

? * (S 0 , u,)) = (S 0 , I OP)

? * (S 0 , ID1, *) = (S 0 , ID)

? * (S 0 , ID1, ?) = (S 0 , ID)

? * (S 0 , ID1, () = (S 0 , ID)

? * (S 0 , ID1,)) = (S 0 , ID)

? * (S 0 , ID1, u) = (S 0 , ID)

? * (S 0 , ID1, k) = (S 0 , ID)

? * (S 0 , ID1, -) = (S 0 , ID)

? * (S 0 , ID1, +) = (S 0 , ID)

? * (S 0 , u,)) = (S 0 , ID)

? * (S 0 , u, ?) = (S 0 , BO)

? * (S 0 , u, k) = (S 0 , ID)

? * (S 0 , u, *)) = (S 0 , ID)

? * (S 0 , u, -)) = (S 0 , ID)

? * (S 0 , u, +)) = (S 0 , ID)

? * (S 0 , u, d)) = (S 0 , ID)

? * (S 0 , u, t)) = (S 0 , ID)

? * (S 0 , u, =)) = (S 0 , ID)

? * (S 0 , CO, ?) = (S 0 , CO)

? * (S 0 , CO, +) = (S 0 , CO)

? * (S 0 , CO, -) = (S 0 , CO)

? * (S 0 , CO, *) = (S 0 , CO)

? * (S 0 , CO,;) = (S 0 , CO)

? * (S 0 , CO, d) = (S 0 , CO)

? * (S 0 , CO, t) = (S 0 , CO)

? * (S 0 , CO,)) = (S 0 , CO)

? * (S 0 , k, +) = (S 0 , CO)

? * (S 0 , k, -) = (S 0 , CO)

? * (S 0 , k, *) = (S 0 , CO)

? * (S 0 , k,;) = (S 0 , CO)

?? * (S 0 , k, d) = (S 0 , CO)

? * (S 0 , k, t) = (S 0 , CO)

? * (S 0 , k,)) = (S 0 , CO)

? * (S 0 , k, () = (S 0 , CO)

2.2.3 Pelaksanaan perisian parser

Penganalisis sintaksis (penghurai) membaca fail leksem yang dijana oleh penganalisis leksikal, melakukan penghuraian tatabahasa dan mengeluarkan mesej tentang ralat sintaks jika ada, dan mencipta bentuk perantaraan merekod program asal. Asas untuk pembangunan parser ialah reka bentuk dan pelaksanaan mesin majalah yang sepadan.

Untuk penghuraian bawah ke atas untuk penghurai bawah ke atas yang menentukan selepas mengurangkannya kepada jenis yang betul Ia dikehendaki menggunakan fungsi AFTER dan ROLL untuk mereka bentuk mesin stor dengan penerangan terperinci tentang semua peralihan dalam fungsi peralihan.

Apabila membangunkan mesin layan diri, kami membina fungsi peralihan yang akan menjadi asas penghurai. Semua fungsi peralihan boleh dibahagikan kepada dua jenis:

Kitaran operasi mesin majalah tanpa membaca simbol input (kitaran kosong);

Kebijaksanaan pengendalian mesin majalah dengan membaca simbol input.

Apabila melaksanakan penganalisis leksikal, kami membahagikan program kepada leksem dan menulisnya ke dalam senarai. Kami kemudian memproses senarai ini dalam parser. Kami menghantar program (senarai), simbol awal (PG) dan penanda bawah mesin stor (h0) ke input, selepas itu fungsi peralihan yang dikehendaki dipilih dan panggilan rekursif dibuat.

Gambar rajah program parser ditunjukkan dalam Lampiran B dalam Rajah B.2.

2.2.4 Pembangunan modul tafsiran

Apabila membangunkan modul tafsiran sebagai bentuk perantaraan program asal Bentuk notasi postfix paling kerap digunakan, yang menjadikannya agak mudah untuk melaksanakan proses melaksanakan (mentafsir) program terjemahan.

Mari kita pertimbangkan prinsip asas membentuk dan melaksanakan bentuk postfix bagi ungkapan penulisan.

Peraturan asas untuk menukar ungkapan infiks kepada postfix adalah seperti berikut.

Operan baca ditambah pada tatatanda postfix dan operasi ditulis pada tindanan.

Jika operasi di bahagian atas tindanan mempunyai keutamaan yang lebih tinggi (atau sama) daripada operasi yang sedang dibaca, maka operasi pada tindanan ditambahkan pada entri postfix dan operasi semasa ditolak ke tindanan. Jika tidak (pada keutamaan yang lebih rendah), hanya operasi semasa ditolak ke tindanan.

Tanda kurung pembukaan yang dibaca ditolak ke tindanan.

Selepas pendakap penutup dibaca, semua operasi sehingga pendakap bukaan pertama muncul dari tindanan dan ditambah pada entri postfix, selepas itu kedua-dua pendakap pembukaan dan penutup dibuang, i.e. tidak diletakkan pada rekod postfix atau pada timbunan.

Selepas keseluruhan ungkapan dibaca, baki operasi pada tindanan ditambahkan pada entri postfix.

Notasi postfix bagi ungkapan membolehkan ia dikira seperti berikut.

Jika token ialah operan, ia ditulis pada timbunan. Jika token ialah operasi, maka operasi yang ditentukan dilakukan pada elemen terakhir (elemen terakhir) yang ditulis pada timbunan, dan elemen tersebut (elemen) digantikan pada timbunan oleh hasil operasi.

Jika analisis leksikal dan sintaksis telah berjaya diselesaikan, maka kita meneruskan ke tafsiran. Mula-mula, kami membuat ayat daripada perkataan, kemudian kami menterjemahkan ungkapan itu ke dalam tatatanda postfix dan mengira.

Rajah operasi penterjemah ditunjukkan dalam Lampiran B dalam Rajah B.3.

2.3 Pengekodan

Program ini dilaksanakan dalam bahasa C# dalam persekitaran Pengaturcaraan visual Studio 2010. Teks program dibentangkan dalam Lampiran A.

Program ini mengandungi lima kelas. Antara muka pengguna dilaksanakan menggunakan kelas MainForn. Menggunakan kelas LexAnalysis, modul analisis leksikal dilaksanakan, SynAnalysis ialah modul analisis sintaksis, Intepreter ialah modul tafsiran, ProgramisciJakPolska ialah kelas tambahan untuk menterjemah ungkapan ke dalam notasi Poland terbalik (postfix).

Tujuan prosedur dan fungsi yang dilaksanakan dalam program diterangkan dalam jadual 6,7,8.

Jadual 6 - Tujuan prosedur dan fungsi analisis leksikal

Dokumen yang serupa

Penterjemah sebagai program atau cara teknikal, menyiarkan program tersebut. Pertimbangan ciri utama pembinaan penganalisis leksikal. Pengenalan kepada peringkat membangunkan penterjemah daripada subset terhad bahasa peringkat tinggi.

kerja kursus, ditambah 08/06/2013

Reka bentuk penganalisis leksikal dan sintaksis untuk bahasa pendidikan. Peraturan untuk menukar ungkapan logik kepada POLYZ. Pembentukan triad, pengoptimuman senarai mereka. Struktur logik program. Menguji modul penterjemah-jurubahasa.

kerja kursus, ditambah 05/28/2013

Ciri-ciri umum dan penilaian keupayaan bahasa pengaturcaraan C-Sharp, ciri yang serupa dan tersendiri daripada C++ dan Java. Pembangunan penganalisis leksikal dan sintaksis menggunakan bahasa pengaturcaraan ini. Menyusun jadual penghuraian.

kerja kursus, ditambah 06/11/2010

Mereka bentuk program penganalisis yang terdiri daripada dua bahagian: penganalisis leksikal yang memecahkan teks sumber program kepada leksem dan mengisi jadual nama; penghurai yang menyemak teks untuk pematuhan dengan tatabahasa yang diberikan.

kerja kursus, ditambah 06/14/2010

Menulis program yang melaksanakan analisis leksikal dan sintaksis bahasa pengaturcaraan input, menghasilkan jadual leksem yang menunjukkan jenis dan nilainya, dan juga membina pepohon sintaks; teks bahasa input dimasukkan dari papan kekunci.

kerja kursus, tambah 23/02/2012

Metodologi untuk pembangunan dan pelaksanaan separa penterjemah untuk bahasa C menggunakan bahasa C++, yang membahagikan rantaian aksara asal kepada binaan bahasa tidak boleh dibahagikan yang minimum berdasarkan perbendaharaan kata bahasa tersebut. Analisis operasi program.

kerja kursus, ditambah 03/19/2012

Struktur, klasifikasi dan keperluan untuk pelaksanaan pengkompil. Reka bentuk dan pelaksanaan bahagian analisis pengkompil bahasa C++. Kaedah untuk melaksanakan analisis leksikal. Algoritma untuk operasi parser. Prinsip pelaksanaan perisian.

kerja kursus, ditambah 26/01/2013

Penciptaan penterjemah yang memproses kod program dalam Pascal dan, menggunakan operator yang setara, menjana program dalam C. Ciri-ciri spesifikasi luaran dan operasi penganalisis leksikal. Struktur program, memaparkan hasil pada skrin.

kerja kursus, ditambah 07/02/2011

Kaedah analisis tatabahasa. Pembangunan struktur penterjemah pendidikan dalam bahasa pengaturcaraan asas Objek Pascal dalam persekitaran pengaturcaraan visual berorientasikan objek Borland DELPHI 6.0 menggunakan sistem pengendalian Windows XP.

kerja kursus, ditambah 05/12/2013

Pelaksanaan perisian aplikasi desktop menggunakan bahasa pengaturcaraan C#. Reka bentuk dan struktur antaramuka pengguna, keperluan untuknya dan penilaian kefungsian. Pembangunan manual pengguna dan penggunaannya.

Alamat. Peranti berfungsi yang menukar alamat maya kepada alamat sebenar.
Dialog. Menyediakan penggunaan bahasa pengaturcaraan dalam mod perkongsian masa.
Berbilang pas. Membentuk modul objek atas beberapa paparan program sumber.
belakang. Sama seperti penerjemah. Lihat juga: decompiler, disassembler.
Pas tunggal. Membentuk modul objek dalam satu paparan berurutan program sumber.
Mengoptimumkan. Melakukan pengoptimuman kod dalam modul objek yang dijana.
Berorientasikan sintaksis (didorong secara sintaksis). Menerima sebagai input penerangan tentang sintaks dan semantik bahasa dan teks dalam bahasa yang diterangkan, yang diterjemahkan mengikut huraian yang diberikan.
Ujian. Satu set arahan makro bahasa himpunan yang membolehkan anda menetapkan pelbagai prosedur penyahpepijatan dalam program yang ditulis dalam bahasa himpunan.

Tujuan penyiaran- menukar teks dari satu bahasa ke bahasa lain, yang boleh difahami oleh penerima teks. Dalam kes program penterjemah, penerima ialah peranti teknikal (pemproses) atau program penterjemah.

Bahasa pemproses (kod mesin) biasanya peringkat rendah. Terdapat platform yang menggunakan bahasa mesin peringkat tinggi (contohnya, iAPX-432), tetapi ia adalah pengecualian kepada peraturan kerana kerumitan dan kos yang tinggi. Penterjemah yang menukar atur cara kepada bahasa mesin yang diterima dan dilaksanakan secara langsung oleh pemproses dipanggil penyusun.

Proses penyusunan biasanya terdiri daripada beberapa peringkat: analisis leksikal, sintaksis dan semantik (analisis Semantik Inggeris), penjanaan kod perantaraan, pengoptimuman dan penjanaan kod mesin yang terhasil. Di samping itu, program biasanya bergantung pada perkhidmatan yang disediakan oleh sistem pengendalian dan perpustakaan pihak ketiga (contohnya, fail I/O atau antara muka grafik), dan kod mesin program mesti dipautkan kepada perkhidmatan ini. Memautkan dengan perpustakaan statik dilakukan oleh pemaut atau pemaut (yang boleh menjadi atur cara yang berasingan atau sebahagian daripada pengkompil), manakala pemautan dengan sistem pengendalian dan perpustakaan dinamik dilakukan apabila pemuat mula melaksanakan atur cara.

Kaedah pelaksanaan lain ialah apabila program dilaksanakan menggunakan jurubahasa tiada siaran langsung. Perisian penterjemah memodelkan mesin yang kitaran pengambilan-eksekusinya beroperasi pada arahan dalam bahasa peringkat tinggi, bukannya pada arahan mesin. Simulasi perisian ini mencipta mesin maya yang melaksanakan bahasa. Pendekatan ini dipanggil tafsiran tulen. Tafsiran tulen biasanya digunakan untuk bahasa dengan struktur mudah (contohnya, APL atau Lisp). Jurubahasa baris arahan perintah proses dalam skrip dalam UNIX atau dalam fail kelompok (.bat) dalam MS-DOS, juga biasanya dalam mod tafsiran tulen.

Terdapat kompromi antara kompilasi dan tafsiran tulen dalam pelaksanaan bahasa pengaturcaraan, apabila jurubahasa, sebelum melaksanakan program, menterjemahkannya ke dalam bahasa perantaraan (contohnya, ke dalam bytecode atau p-code), lebih mudah untuk tafsiran (iaitu, kita bercakap tentang jurubahasa dengan penterjemah terbina dalam) . Kaedah ini dipanggil pelaksanaan bercampur. Contoh pelaksanaan bahasa campuran ialah Perl. Pendekatan ini menggabungkan kedua-dua kelebihan penyusun dan jurubahasa ( kelajuan tinggi pelaksanaan dan kemudahan penggunaan) dan keburukan (terjemahan dan penyimpanan program dalam bahasa perantaraan memerlukan sumber tambahan; jurubahasa mesti disediakan untuk melaksanakan program pada mesin sasaran). Juga, seperti dalam kes pengkompil, pelaksanaan bercampur memerlukan kod sumber bebas daripada ralat (leksikal, sintaksis dan semantik) sebelum pelaksanaan.

Siarkan Dan tafsiran - proses yang berbeza: Penterjemahan memperkatakan penterjemahan program dari satu bahasa ke bahasa lain, manakala pentafsiran bertanggungjawab untuk pelaksanaan program. Walau bagaimanapun, kerana tujuan terjemahan biasanya untuk menyediakan program untuk tafsiran, proses ini biasanya dipertimbangkan bersama. Sebagai contoh, bahasa pengaturcaraan sering dicirikan sebagai "disusun" atau "ditafsirkan", bergantung pada sama ada kompilasi atau tafsiran mendominasi penggunaan bahasa tersebut. Lebih-lebih lagi, hampir semua bahasa pengaturcaraan Level rendah dan bahasa generasi ketiga, seperti assembler, C, atau Modula-2, disusun, manakala bahasa peringkat tinggi, seperti Python atau SQL, ditafsirkan.

Sebaliknya, terdapat interpenetrasi proses terjemahan dan tafsiran: jurubahasa boleh menyusun (termasuk kompilasi dinamik), dan penterjemah mungkin memerlukan tafsiran untuk pembinaan pengaturcaraan meta (contohnya, untuk makro dalam bahasa himpunan, kompilasi bersyarat dalam C, atau untuk templat dalam C++).

Selain itu, bahasa pengaturcaraan yang sama boleh diterjemahkan dan ditafsirkan, dan dalam kedua-dua kes mesti ada peringkat umum analisis dan pengiktirafan pembinaan dan arahan bahasa sumber. Ini terpakai kepada kedua-dua perisian dan pelaksanaan perkakasan - contohnya, pemproses keluarga x86, sebelum melaksanakan arahan bahasa mesin, melaksanakan penyahkodannya, menyerlahkan dalam opcode medan operan (daftar, alamat memori, nilai segera), kedalaman bit, dsb. ., dan dalam Pemproses Pentium dengan seni bina NetBurst, kod mesin biasanya diterjemahkan ke dalam urutan operasi mikro sebelum disimpan dalam cache dalaman.

Matlamat dan objektif disiplin. Konsep dan definisi asas. Ciri-ciri umum bahasa pengaturcaraan dan penterjemah. Struktur umum penterjemah. Pilihan untuk interaksi blok penterjemah.

Matlamat dan objektif disiplin

Pada masa ini bahasa buatan, yang menggunakan perwakilan teks untuk menerangkan bidang subjek, digunakan secara meluas bukan sahaja dalam pengaturcaraan, tetapi juga dalam bidang lain. Dengan bantuan mereka, struktur semua jenis dokumen, tiga dimensi alam maya, antara muka grafik pengguna dan banyak objek lain yang digunakan dalam model dan dalam dunia sebenar. Untuk membolehkan huraian teks ini disusun dengan betul, dan kemudian dikenali dan ditafsir dengan betul, kaedah khas analisis dan transformasinya digunakan. Kaedah ini berdasarkan teori bahasa dan tatabahasa formal, serta teori automata. Sistem perisian yang direka untuk menganalisis dan mentafsir teks dipanggil penterjemah.

Walaupun fakta bahawa beribu-ribu bahasa yang berbeza dan penterjemah mereka telah dibangunkan setakat ini, proses mencipta aplikasi baru di kawasan ini tidak berhenti. Ini berkaitan dengan perkembangan teknologi pengeluaran sistem pengkomputeran, dan dengan keperluan untuk menyelesaikan masalah gunaan yang semakin kompleks. Di samping itu, unsur-unsur teori bahasa dan tatabahasa formal boleh digunakan dalam pelbagai bidang lain, contohnya, apabila menerangkan struktur data, fail, imej, yang dibentangkan bukan dalam teks, tetapi dalam format binari. Kaedah ini juga berguna apabila membangunkan penterjemah anda sendiri, walaupun di mana analog yang sepadan sudah wujud. Perkembangan sedemikian mungkin disebabkan oleh pelbagai sebab, khususnya, batasan fungsi, kekurangan penyetempatan, dan kecekapan rendah. Sebagai contoh, salah satu perkembangan terkini oleh Microsoft ialah bahasa pengaturcaraan C#, dan salah satu sebab penciptaannya adalah keinginan untuk mengurangkan populariti bahasa pengaturcaraan Java. Terdapat banyak contoh lain di mana membangunkan penterjemah anda sendiri mungkin relevan. Oleh itu, asas-asas teori bahasa dan tatabahasa formal, serta kaedah praktikal pembangunan penterjemah terletak pada asas pendidikan kejuruteraan dalam sains komputer dan Teknologi komputer.

Bahan yang dicadangkan menyentuh asas kaedah untuk membangunkan penterjemah dan mengandungi maklumat yang diperlukan untuk mengkaji logik fungsi mereka, alat matematik yang digunakan (teori bahasa formal dan tatabahasa formal, bahasa metal). Ia digunakan sebagai sebahagian daripada kursus kuliah sepanjang semester yang diberikan untuk pelbagai kepakaran di Fakulti Informatik dan Sains Komputer Universiti Teknikal Negeri Krasnoyarsk. Semasa kerja makmal, kenalan langsung dengan kaedah individu untuk mencipta penterjemah dijalankan.

Tujuan disiplin: untuk memberikan pengetahuan tentang asas-asas teori bahasa dan tatabahasa formal, teori automata, kaedah membangunkan penterjemah.

Untuk mencapai matlamat ini, tugas-tugas berikut diselesaikan semasa mengajar disiplin:

Kursus kuliah meneliti prinsip umum mengatur proses terjemahan dan struktur penterjemah. Asas-asas teori membina penterjemah dipelajari.
Dalam kelas makmal dan semasa kerja bebas, penyatuan praktikal pengetahuan teori yang diperolehi dijalankan: penterjemah sedang dibangunkan untuk bahasa mudah pengaturcaraan.

Konsep dan definisi asas

Kebanyakan definisi yang dipertimbangkan dipinjam daripada [ARNFTS Kamus penerangan Inggeris-Rusia-Jerman-Perancis mengenai teknologi komputer dan pemprosesan data, 4132 istilah. Di bawah. ed. A.A. Dorodnitsyna. M.: 1978. 416 hlm.) ].

Penterjemah - program perkhidmatan yang menukar program sumber yang disediakan dalam bahasa pengaturcaraan input kepada program kerja, diwakili dalam bahasa objek.

Takrifan di atas digunakan untuk semua jenis program penyiaran. Namun begitu, setiap program ini mungkin mempunyai ciri tersendiri dalam mengatur proses penyiaran. Pada masa ini, penterjemah dibahagikan kepada tiga kumpulan utama: penghimpun, penyusun dan jurubahasa.

Asembler - program utiliti sistem yang menukar binaan simbolik kepada arahan bahasa mesin. Ciri khusus pemasang ialah mereka melaksanakan terjemahan verbatim satu arahan simbolik ke dalam satu arahan mesin. Oleh itu, bahasa himpunan (juga dipanggil autokod) direka untuk memudahkan persepsi sistem arahan komputer dan mempercepatkan pengaturcaraan dalam sistem arahan ini. Adalah lebih mudah bagi seorang pengaturcara untuk mengingati penunjuk mnemonik arahan mesin daripada kod binari mereka. Oleh itu, keuntungan utama dicapai bukan dengan meningkatkan kuasa arahan individu, tetapi dengan meningkatkan kecekapan persepsi mereka.

Pada masa yang sama, bahasa himpunan, sebagai tambahan kepada analog perintah mesin, mengandungi banyak arahan tambahan yang memudahkan, khususnya, mengurus sumber komputer, menulis serpihan berulang, dan membina program berbilang modul. Oleh itu, ekspresi bahasa adalah lebih kaya daripada sekadar bahasa pengekodan simbolik, yang sangat meningkatkan kecekapan pengaturcaraan.

Penyusun - ialah program perkhidmatan yang menterjemahkan atur cara yang ditulis dalam bahasa pengaturcaraan sumber kepada bahasa mesin. Sama seperti penghimpun, pengkompil menukar atur cara daripada satu bahasa ke bahasa lain (paling kerap, ke dalam bahasa komputer tertentu). Pada masa yang sama, arahan bahasa sumber berbeza dengan ketara dalam organisasi dan kuasa daripada arahan bahasa mesin. Terdapat bahasa di mana satu arahan bahasa sumber diterjemahkan ke dalam 7-10 arahan mesin. Walau bagaimanapun, terdapat juga bahasa di mana setiap arahan boleh mempunyai 100 atau lebih arahan mesin (contohnya, Prolog). Di samping itu, bahasa sumber sering menggunakan penaipan data yang ketat, dilakukan melalui penerangan awal mereka. Pengaturcaraan mungkin tidak bergantung pada pengekodan algoritma, tetapi pada pemikiran dengan teliti tentang struktur data atau kelas. Proses penterjemahan daripada bahasa tersebut biasanya dipanggil kompilasi, dan bahasa sumber biasanya merupakan bahasa pengaturcaraan peringkat tinggi (atau bahasa peringkat tinggi). Abstraksi bahasa pengaturcaraan daripada sistem arahan komputer membawa kepada penciptaan bebas pelbagai bahasa yang memberi tumpuan kepada menyelesaikan masalah tertentu. Bahasa telah muncul untuk pengiraan saintifik, pengiraan ekonomi, akses kepada pangkalan data, dan lain-lain.

Jurubahasa - program atau peranti yang menjalankan terjemahan operator demi operator dan pelaksanaan program asal. Tidak seperti pengkompil, jurubahasa tidak menghasilkan program dalam bahasa mesin. Setelah mengenali arahan dalam bahasa sumber, ia segera melaksanakannya. Kedua-dua penyusun dan jurubahasa menggunakan kaedah yang sama untuk menganalisis kod sumber program. Tetapi jurubahasa membenarkan anda untuk mula memproses data selepas menulis walaupun satu arahan. Ini menjadikan proses pembangunan dan penyahpepijatan program lebih fleksibel. Di samping itu, ketiadaan kod mesin keluaran memungkinkan untuk tidak "menghancurkan" peranti luaran dengan fail tambahan, dan penterjemah itu sendiri boleh dengan mudah disesuaikan dengan mana-mana seni bina mesin, setelah membangunkannya sekali sahaja dalam bahasa pengaturcaraan yang digunakan secara meluas. Oleh itu, bahasa yang ditafsirkan seperti Skrip Java dan Skrip VB telah meluas. Kelemahan jurubahasa ialah kelajuan rendah pelaksanaan program. Program yang biasanya ditafsirkan dilaksanakan 50-100 kali program yang lebih perlahan ditulis dalam kod mesin.

Emulator - program atau perisian dan alat perkakasan yang menyediakan keupayaan, tanpa pengaturcaraan semula, untuk melaksanakan pada komputer tertentu program yang menggunakan kod atau kaedah melaksanakan operasi yang berbeza daripada komputer yang diberikan. Emulator adalah serupa dengan penterjemah kerana ia melaksanakan secara langsung atur cara yang ditulis dalam bahasa tertentu. Walau bagaimanapun, selalunya ia adalah bahasa mesin atau kod perantaraan. Kedua-duanya mewakili arahan dalam kod binari yang boleh dilaksanakan serta-merta selepas kod operasi diiktiraf. Tidak seperti program teks, tidak perlu mengenali struktur program atau memilih operan.

Emulator digunakan agak kerap untuk pelbagai tujuan. Sebagai contoh, apabila membangunkan sistem pengkomputeran baharu, emulator pertama kali dicipta yang menjalankan program yang dibangunkan untuk komputer yang belum wujud. Ini membolehkan anda menilai sistem arahan dan membangunkan asas perisian walaupun sebelum peralatan yang sepadan dicipta.

Selalunya, emulator digunakan untuk menjalankan program lama pada yang baru. komputer. Biasanya, komputer yang lebih baharu adalah lebih pantas dan mempunyai peranti yang lebih baik. Ini membolehkan anda meniru program lama dengan lebih cekap daripada menjalankannya pada komputer lama. Contoh pendekatan ini ialah pembangunan emulator komputer rumah ZX Spectrum dengan mikropemproses Z80. Masih terdapat orang yang suka bermain permainan pada emulator yang sudah lapuk, tetapi masih tidak kehilangan daya tarikan mereka dahulu, program permainan. Emulator juga boleh digunakan sebagai analog moden yang lebih murah sistem komputer, sambil memberikan prestasi yang boleh diterima setara dengan model kelas rendah bagi keluarga seni bina tertentu. Contohnya ialah emulator PC IBM komputer yang serasi, dilaksanakan pada komputer Apple yang lebih berkuasa. Sejumlah emulator yang ditulis untuk IBM PC berjaya menggantikan pelbagai konsol permainan.

Emulator perwakilan perantaraan, serta jurubahasa, boleh dipindahkan dengan mudah dari satu seni bina komputer ke yang lain, membolehkan penciptaan perisian mudah alih. Sifat inilah yang menentukan kejayaan bahasa pengaturcaraan Java, dari mana program ini diterjemahkan ke dalam kod perantaraan. Mesin maya Java yang melaksanakan kod ini tidak lebih daripada emulator yang dijalankan di bawah mana-mana sistem pengendalian moden.

Transkoder - program atau peranti perisian, menterjemah program yang ditulis dalam bahasa mesin satu komputer kepada program dalam bahasa mesin komputer lain. Jika emulator adalah analog penterjemah yang kurang pintar, maka transcoder bertindak dalam kapasiti yang sama berhubung dengan pengkompil. Begitu juga, kod mesin sumber (dan biasanya binari) atau perwakilan perantaraan ditukar kepada kod lain yang serupa dengan satu arahan dan tanpa sebarang analisis umum struktur program sumber. Transkoder berguna apabila memindahkan atur cara dari satu seni bina komputer ke yang lain. Ia juga boleh digunakan untuk membina semula teks program bahasa peringkat tinggi daripada kod binari sedia ada.

Makropemproses - program yang menggantikan satu urutan aksara dengan yang lain[Brown]. Ini adalah jenis penyusun. Ia menjana teks output dengan pemprosesan sisipan khas, bertempat di teks sumber. Sisipan ini direka bentuk dengan cara yang istimewa dan tergolong dalam binaan bahasa yang dipanggil makrolanguage. Makropemproses sering digunakan sebagai alat tambah kepada bahasa pengaturcaraan, meningkat kefungsian sistem pengaturcaraan. Hampir mana-mana pemasang mengandungi makropemproses, yang meningkatkan kecekapan membangunkan program mesin. Sistem pengaturcaraan sedemikian biasanya dipanggil macroassemblers.

Makropemproses juga digunakan dengan bahasa peringkat tinggi. Mereka meningkatkan fungsi bahasa seperti PL/1, C, C++. Pemproses makro digunakan secara meluas terutamanya dalam C dan C++, menjadikannya lebih mudah untuk menulis atur cara. Contoh penggunaan meluas makropemproses ialah perpustakaan kelas Microsoft Foundation Classes (MFC). Ia melaksanakan peta mesej dan objek program lain melalui sisipan makro. Pada masa yang sama, makropemproses meningkatkan kecekapan pengaturcaraan tanpa mengubah sintaks dan semantik bahasa.

Sintaks - satu set peraturan bahasa tertentu yang menentukan pembentukan unsur-unsurnya. Dengan kata lain, ini satu set peraturan untuk pembentukan urutan aksara yang signifikan secara semantik dalam bahasa tertentu. Sintaks ditentukan menggunakan peraturan yang menerangkan konsep bahasa. Contoh konsep ialah: pembolehubah, ungkapan, pengendali, prosedur. Urutan konsep dan penggunaannya yang boleh diterima dalam peraturan menentukan struktur yang betul secara sintaksis yang membentuk atur cara. Ia adalah hierarki objek, dan bukan cara mereka berinteraksi antara satu sama lain, yang ditakrifkan melalui sintaks. Sebagai contoh, pernyataan hanya boleh berlaku dalam prosedur, ungkapan dalam pernyataan, pembolehubah boleh terdiri daripada nama dan indeks pilihan, dsb. Sintaks tidak dikaitkan dengan fenomena sedemikian dalam program sebagai "melompat ke label yang tidak wujud" atau "pembolehubah dengan nama yang diberikan tidak ditakrifkan." Inilah yang dilakukan oleh semantik.

Semantik - peraturan dan syarat yang menentukan hubungan antara unsur bahasa dengan makna semantiknya, serta tafsiran makna makna binaan sintaksis bahasa.. Objek bahasa pengaturcaraan bukan sahaja diletakkan dalam teks mengikut hierarki tertentu, tetapi juga saling berkaitan melalui konsep lain yang membentuk pelbagai persatuan. Sebagai contoh, pembolehubah, yang sintaksnya mentakrifkan lokasi yang sah hanya dalam pengisytiharan dan beberapa pernyataan, mempunyai jenis tertentu, boleh digunakan dengan bilangan operasi yang terhad, mempunyai alamat, saiz, dan mesti diisytiharkan sebelum ia boleh. digunakan dalam program.

Penganalisis sintaksis - komponen pengkompil yang menyemak penyataan sumber untuk pematuhan dengan peraturan sintaksis dan semantik bahasa pengaturcaraan tertentu. Walaupun namanya, penganalisis menyemak kedua-dua sintaks dan semantik. Ia terdiri daripada beberapa blok, setiap satunya menyelesaikan masalahnya sendiri. Ia akan dibincangkan dengan lebih terperinci apabila menerangkan struktur penterjemah.

Ciri umum bahasa pengaturcaraan dan penterjemah

Bahasa pengaturcaraan agak berbeza antara satu sama lain dalam tujuan, struktur, kerumitan semantik, dan kaedah pelaksanaan. Ini mengenakan ciri khususnya sendiri pada pembangunan penterjemah tertentu.

Bahasa pengaturcaraan adalah alat untuk menyelesaikan masalah dalam bidang subjek yang berbeza, yang menentukan spesifik organisasi mereka dan perbezaan tujuan. Contohnya termasuk bahasa seperti Fortran, yang berorientasikan kepada pengiraan saintifik, C, yang bertujuan untuk pengaturcaraan sistem, Prolog, yang menerangkan masalah inferens dengan berkesan, dan Lisp, yang digunakan untuk pemprosesan senarai rekursif. Contoh-contoh ini boleh diteruskan. Setiap bidang subjek meletakkan keperluannya sendiri pada organisasi bahasa itu sendiri. Oleh itu, kita boleh perhatikan pelbagai bentuk perwakilan operator dan ungkapan, perbezaan dalam set operasi asas, dan penurunan kecekapan pengaturcaraan apabila menyelesaikan masalah yang tidak berkaitan dengan kawasan subjek. Perbezaan linguistik juga tercermin dalam struktur penterjemah. Lisp dan Prolog paling kerap dilaksanakan dalam mod tafsiran kerana fakta bahawa ia menggunakan penjanaan dinamik jenis data semasa pengiraan. Penterjemah Fortran dicirikan oleh pengoptimuman agresif kod mesin yang terhasil, yang menjadi mungkin disebabkan oleh semantik binaan bahasa yang agak mudah - khususnya, kerana ketiadaan mekanisme untuk penamaan alternatif pembolehubah melalui penunjuk atau rujukan. Kehadiran penunjuk dalam bahasa C mengenakan keperluan khusus untuk peruntukan memori dinamik.

Struktur bahasa mencirikan hubungan hierarki antara konsepnya, yang digambarkan oleh peraturan sintaksis. Bahasa pengaturcaraan boleh sangat berbeza antara satu sama lain dalam organisasi konsep individu dan hubungan antara mereka. Bahasa pengaturcaraan PL/1 membenarkan prosedur dan fungsi sarang sewenang-wenangnya, manakala dalam C semua fungsi mesti berada pada tahap sarang luar. Bahasa C++ membenarkan pembolehubah diisytiharkan pada mana-mana titik dalam program sebelum penggunaan pertamanya, manakala dalam pembolehubah Pascal mesti ditakrifkan dalam kawasan pengisytiharan khas. Mengambil ini lebih jauh ialah PL/1, yang membenarkan pembolehubah diisytiharkan selepas ia digunakan. Atau anda boleh meninggalkan penerangan sama sekali dan menggunakan peraturan lalai. Bergantung pada keputusan yang dibuat, penterjemah boleh menganalisis program dalam satu atau beberapa pas, yang mempengaruhi kelajuan terjemahan.

Bersama-sama dengan pengaturcaraan prosedur tradisional, juga dipanggil imperatif, terdapat paradigma seperti pengaturcaraan berfungsi, pengaturcaraan logik dan pengaturcaraan berorientasikan objek. Saya berharap paradigma pengaturcaraan prosedur-parametrik yang saya cadangkan akan mengambil tempatnya dalam siri ini [Legalov2000]. Struktur konsep dan objek bahasa sangat bergantung pada paradigma yang dipilih, yang juga mempengaruhi pelaksanaan penterjemah.

Malah bahasa yang sama boleh dilaksanakan dalam beberapa cara. Ini disebabkan oleh fakta bahawa teori tatabahasa formal membenarkan kaedah yang berbeza untuk menghuraikan ayat yang sama. Selaras dengan ini, penterjemah boleh memperoleh hasil yang sama (program objek) daripada teks sumber asal dengan cara yang berbeza.

Pada masa yang sama, semua bahasa pengaturcaraan mempunyai beberapa ciri dan parameter yang sama. Kesamaan ini juga menentukan prinsip penyusunan penterjemah yang serupa untuk semua bahasa.

Bahasa pengaturcaraan direka untuk memudahkan pengaturcaraan. Oleh itu, pengendali dan struktur data mereka lebih berkuasa daripada dalam bahasa mesin.
Untuk meningkatkan keterlihatan program, bukannya kod angka, representasi simbolik atau grafik bagi binaan bahasa digunakan, yang lebih mudah untuk persepsi manusia.
Untuk mana-mana bahasa ia ditakrifkan:

Banyak simbol yang boleh digunakan untuk menulis program yang betul (abjad), elemen asas.
Banyak program yang betul (sintaks).
"Maksud" setiap program yang betul (semantik).

Tanpa mengira spesifik bahasa, mana-mana penterjemah boleh dianggap sebagai penukar berfungsi F, menyediakan pemetaan unik dari X ke Y, di mana X ialah atur cara dalam bahasa sumber, Y ialah atur cara dalam bahasa output. Oleh itu, proses terjemahan itu sendiri boleh dibentangkan secara formal dengan ringkas dan jelas:

Secara rasmi, setiap atur cara X yang betul ialah rangkaian simbol daripada beberapa abjad A, diubah menjadi rantaian Y yang sepadan, terdiri daripada simbol abjad B.

Bahasa pengaturcaraan, seperti mana-mana sistem yang kompleks, ditakrifkan melalui hierarki konsep yang mentakrifkan hubungan antara unsur-unsurnya. Konsep-konsep ini saling berkaitan mengikut peraturan sintaksis. Setiap program yang dibina mengikut peraturan ini mempunyai struktur hierarki yang sepadan.

Dalam hal ini, ciri umum berikut boleh dibezakan tambahan untuk semua bahasa dan programnya: setiap bahasa mesti mengandungi peraturan yang membenarkan menjana program yang sepadan dengan bahasa ini atau mengiktiraf surat-menyurat antara program bertulis dan bahasa tertentu.

Hubungan antara struktur atur cara dan bahasa pengaturcaraan dipanggil pemetaan sintaksis.

Sebagai contoh, pertimbangkan hubungan antara struktur hierarki dan rentetan simbol yang mentakrifkan ungkapan aritmetik berikut:

Dalam kebanyakan bahasa pengaturcaraan ungkapan ini mentakrifkan hierarki objek program, yang boleh dipaparkan sebagai pokok (Rajah 1.1.):

Bulatan mewakili simbol yang digunakan sebagai struktur asas, dan segi empat tepat mewakili konsep komposit yang mempunyai struktur hierarki dan mungkin rekursif. Hierarki ini ditakrifkan menggunakan peraturan sintaksis yang ditulis dalam bahasa khas yang dipanggil metalanguage (metalanguage akan dibincangkan dengan lebih terperinci semasa mempelajari tatabahasa formal):

<выражение> ::= <слагаемое> | <выражение> + <слагаемое>

<слагаемое> ::= <множитель> | <слагаемое> * <множитель>

<множитель> ::= <буква> | (<выражение>)

<буква>

Catatan. Tanda "::=" dibaca sebagai "ini". Paip "|" berbunyi seperti "atau".

Jika peraturan ditulis secara berbeza, maka struktur hierarki. Contohnya ialah kaedah berikut entri peraturan:

<выражение> ::= <операнд> | <выражение> + < операнд > | <выражение> * < операнд >

<операнд> ::= <буква> | (<выражение>)

<буква>::= a | b | c | d | i | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z

Hasil daripada menghurai yang sama ungkapan aritmetik struktur hierarki akan dibina, ditunjukkan dalam Rajah. 1.2.

Perlu diingatkan bahawa struktur hierarki dalam kes umum mungkin sama sekali tidak berkaitan dengan semantik ungkapan. Dalam kedua-dua kes, keutamaan operasi boleh dilaksanakan mengikut peraturan yang diterima umum, apabila pendaraban mendahului penambahan (atau sebaliknya, semua operasi boleh mempunyai keutamaan yang sama di bawah mana-mana set peraturan). Walau bagaimanapun, struktur pertama jelas menyokong pelaksanaan selanjutnya keutamaan yang diterima umum, manakala yang kedua lebih sesuai untuk melaksanakan operasi dengan keutamaan yang sama dan melaksanakannya dari kanan ke kiri.

Proses mencari struktur sintaksis program yang diberikan dipanggil menghurai.

Struktur sintaksis yang betul dalam satu bahasa mungkin tidak betul dalam bahasa lain. Sebagai contoh, dalam bahasa Forth ungkapan yang diberikan tidak akan dikenali. Walau bagaimanapun, untuk bahasa ini ungkapan postfix yang betul ialah:

Struktur sintaksisnya diterangkan oleh peraturan:

<выражение> ::= <буква> | <операнд> <операнд> <операция>

< операнд > ::= < буква > | < выражение >

< операция > ::= + | *

<буква>::= a | b | c | d | i | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z

Pokok hierarki yang mentakrifkan struktur sintaksis dibentangkan dalam Rajah. 1.3.

Pengetahuan tentang semantik bahasa membolehkan anda memisahkannya daripada sintaksnya dan menggunakannya untuk penukaran kepada bahasa lain (untuk menjana kod).

Perihalan semantik dan pengiktirafan ketepatannya biasanya merupakan bahagian penterjemah yang paling intensif buruh dan besar, kerana ia perlu untuk menghitung dan menganalisis banyak pilihan untuk gabungan operasi dan operan yang sah.

Struktur penterjemah umum

Sifat dan corak biasa wujud dalam kedua-dua bahasa pengaturcaraan yang berbeza dan penterjemah daripada bahasa ini. Mereka menjalani proses serupa untuk menukar teks sumber. Walaupun pada hakikatnya interaksi proses ini boleh diatur dengan cara yang berbeza, adalah mungkin untuk mengenal pasti fungsi yang pelaksanaannya membawa kepada hasil yang sama. Mari kita panggil fungsi tersebut sebagai fasa proses terjemahan.

Memandangkan persamaan antara pengkompil dan jurubahasa, mari kita lihat fasa-fasa yang wujud dalam pengkompil. Ia menyerlahkan:

Fasa analisis leksikal.
Fasa penghuraian yang terdiri daripada:

pengecaman struktur sintaksis;
analisis semantik, semasa kerja dengan jadual dijalankan, menghasilkan perwakilan semantik pertengahan atau model objek bahasa.

Fasa penjanaan kod, yang:

analisis semantik komponen perwakilan perantaraan atau model objek bahasa;
menterjemah perwakilan perantaraan atau model objek kepada kod objek.

Bersama-sama dengan fasa utama proses terjemahan, fasa tambahan juga mungkin:

2a. Fasa penerokaan perwakilan pertengahan dan pengoptimuman, yang terdiri daripada: 2a.1. menganalisis ketepatan perwakilan pertengahan;
2a.2. pengoptimuman perwakilan perantaraan.

3a. Fasa pengoptimuman kod objek.

Jurubahasa berbeza kerana fasa penjanaan kod biasanya digantikan dengan fasa meniru unsur perwakilan perantaraan atau model objek bahasa. Di samping itu, jurubahasa biasanya tidak mengoptimumkan perwakilan perantaraan, tetapi segera menirunya.

Di samping itu, adalah mungkin untuk membezakan proses analisis dan pembetulan ralat yang wujud dalam teks sumber yang diproses program yang seragam untuk semua fasa.

Struktur umum pengkompil, dengan mengambil kira fasa yang ada di dalamnya, dibentangkan dalam Rajah. 1.4.

Ia terdiri daripada penganalisis leksikal, penghurai, penjana kod dan penganalisis ralat. Daripada penjana kod, penterjemah menggunakan emulator (Rajah 1.5), di mana, sebagai tambahan kepada elemen perwakilan perantaraan, data sumber dipindahkan. Output emulator adalah hasil pengiraan.

Penganalisis leksikal (juga dikenali sebagai pengimbas) membaca rentetan input aksara dan mengumpulkannya ke dalam struktur asas yang dipanggil leksem. Setiap token mempunyai kelas dan makna. Biasanya, calon untuk peranan leksem adalah konstruk bahasa asas, contohnya, pengecam, nombor nyata, ulasan. Token yang terhasil dihantar ke parser. Pengimbas bukan bahagian wajib penterjemah. Walau bagaimanapun, ia membolehkan anda meningkatkan kecekapan proses terjemahan. Analisis leksikal dibincangkan dengan lebih terperinci dalam topik: "Organisasi analisis leksikal."

Penghurai menghuraikan atur cara sumber menggunakan leksem masuk, membina struktur sintaksis program dan analisis semantik dengan pembentukan model objek bahasa. Model objek mewakili struktur sintaksis, dilengkapi dengan hubungan semantik antara konsep sedia ada. Sambungan ini boleh menjadi:

rujukan kepada pembolehubah, jenis data dan nama prosedur yang diletakkan dalam jadual nama;
sambungan yang menentukan urutan pelaksanaan arahan;
sambungan yang menentukan sarang unsur model objek bahasa dan lain-lain.

Jadi penghurai adalah agak blok kompleks penterjemah. Oleh itu, ia boleh dibahagikan kepada komponen berikut:

pengecam;
blok analisis semantik;
model objek, atau perwakilan perantaraan, yang terdiri daripada jadual nama dan struktur sintaksis.

Struktur umum penghurai ditunjukkan dalam Rajah. 1.6.

Pengecam menerima rangkaian leksem dan, berdasarkannya, melakukan penghuraian mengikut peraturan yang digunakan. Token, apabila berjaya menghurai peraturan, dipindahkan ke penganalisis semantik, yang membina jadual nama dan merekodkan serpihan struktur sintaksis. Selain itu, sambungan semantik tambahan direkodkan antara jadual nama dan struktur sintaksis. Akibatnya, model objek program terbentuk, dibebaskan daripada mengikat kepada sintaks bahasa pengaturcaraan. Selalunya, bukannya struktur sintaksis yang menyalin sepenuhnya hierarki objek bahasa, analog yang dipermudahkan dicipta, yang dipanggil perwakilan perantaraan.

Penganalisis ralat menerima maklumat tentang ralat yang berlaku dalam blok yang berbeza penterjemah. Menggunakan maklumat yang diterima, ia menjana mesej kepada pengguna. selain itu, blok ini boleh cuba membetulkan ralat untuk meneruskan analisis dengan lebih lanjut. Dia juga bertanggungjawab terhadap tindakan yang berkaitan dengan penyiapan program yang betul sekiranya tidak dapat meneruskan siaran.

Penjana kod membina kod mesin objek berdasarkan analisis model objek atau perwakilan perantaraan. Pembinaan kod disertakan dengan tambahan analisis semantik, dikaitkan dengan keperluan untuk menukar arahan umum kepada kod komputer tertentu. Pada peringkat analisis sedemikian, kemungkinan transformasi akhirnya ditentukan, dan pilihan yang berkesan dipilih. Penjanaan kod itu sendiri ialah pengekodan semula satu arahan ke yang lain.

Pilihan untuk interaksi blok penterjemah

Organisasi proses terjemahan, yang menentukan pelaksanaan fasa utama, boleh dijalankan dalam pelbagai cara. Ini ditentukan oleh pelbagai pilihan untuk interaksi blok penterjemah: penganalisis leksikal, penghurai dan penjana kod. Walaupun hasil akhir yang sama, pilihan yang berbeza untuk blok penterjemah berinteraksi memberikan pilihan yang berbeza untuk menyimpan data perantaraan. Terdapat dua pilihan utama untuk interaksi blok penterjemah:

organisasi berbilang pas, di mana setiap fasa adalah proses bebas yang memindahkan kawalan ke fasa seterusnya hanya selepas pemprosesan lengkap datanya;
organisasi laluan tunggal, di mana semua fasa mewakili satu proses dan menghantar data antara satu sama lain dalam serpihan kecil.

Berdasarkan dua pilihan utama, anda juga boleh membuat pelbagai kombinasi daripadanya.

Organisasi interaksi berbilang pas antara blok penterjemah

Versi interaksi blok ini, menggunakan pengkompil sebagai contoh, dibentangkan dalam Rajah 1.7.

Penganalisis leksikal memproses sepenuhnya teks sumber, membentuk rantaian keluaran yang terdiri daripada semua leksem yang diterima. Hanya selepas ini kawalan dipindahkan ke parser. Penghurai menerima rantaian leksem yang dijana dan, berdasarkannya, membentuk perwakilan perantaraan atau model objek. Selepas menerima keseluruhan model objek, ia memberikan kawalan kepada penjana kod. Penjana kod, berdasarkan model objek bahasa, membina kod mesin yang diperlukan

Kelebihan pendekatan ini termasuk:

Pengasingan fasa individu, yang membolehkan pelaksanaan dan penggunaan bebas mereka.
Keupayaan untuk menyimpan data yang diperoleh hasil daripada operasi setiap fasa pada peranti storan luaran dan menggunakannya mengikut keperluan.
Keupayaan untuk mengurangkan jumlah RAM yang diperlukan untuk mengendalikan penterjemah dengan memanggil fasa secara berurutan.

Kelemahannya termasuk:

Kehadiran jumlah besar maklumat perantaraan, dari mana masa ini Hanya sebahagian kecil masa diperlukan.
Kelajuan siaran yang perlahan disebabkan oleh pelaksanaan fasa yang berurutan dan penggunaan peranti storan luaran untuk menjimatkan RAM.

Pendekatan ini mungkin mudah apabila membina penterjemah daripada bahasa pengaturcaraan dengan struktur sintaksis dan semantik yang kompleks (contohnya, PL/I). Dalam situasi sedemikian, terjemahan sukar dicapai dalam satu pas, jadi lebih mudah untuk mewakili keputusan pas sebelumnya sebagai data perantaraan tambahan. Perlu diingatkan bahawa struktur semantik dan sintaksis bahasa yang kompleks boleh menyebabkan laluan tambahan yang diperlukan untuk mewujudkan kebergantungan yang diperlukan. Jumlah pas mungkin lebih daripada sepuluh. Bilangan pas juga boleh dipengaruhi oleh penggunaan ciri bahasa tertentu oleh program, seperti mengisytiharkan pembolehubah dan prosedur selepas ia digunakan, menggunakan peraturan pengisytiharan lalai dan sebagainya.

Organisasi satu laluan interaksi antara blok penterjemah

Salah satu pilihan untuk interaksi blok pengkompil dengan organisasi laluan tunggal dibentangkan dalam Rajah. 1.8.

Dalam kes ini, proses terjemahan berjalan seperti berikut. Penganalisis leksikal membaca serpihan teks sumber yang diperlukan untuk mendapatkan satu leksem. Selepas token dibentuk, ia memanggil parser dan memberikannya token yang dicipta sebagai parameter. Jika penghurai boleh membina elemen seterusnya bagi perwakilan perantaraan, maka ia berbuat demikian dan menghantar serpihan yang dibina kepada penjana kod. Jika tidak, penghurai mengembalikan kawalan kepada pengimbas, dengan itu menjelaskan bahawa token seterusnya telah diproses dan data baharu diperlukan.

Penjana kod berfungsi dengan cara yang sama. Berdasarkan serpihan perwakilan perantaraan yang diterima, ia mencipta serpihan kod objek yang sepadan. Selepas ini, kawalan kembali ke penghurai.

Setelah selesai teks sumber dan selesai pemprosesan semua data perantaraan oleh setiap blok, penganalisis leksikal memulakan proses penamatan program.

Selalunya, penterjemah laluan tunggal menggunakan skema kawalan yang berbeza, di mana penghurai memainkan peranan blok utama (Rajah 1.9).

Penganalisis leksikal dan penjana kod bertindak sebagai subrutin yang dipanggilnya. Sebaik sahaja penghurai memerlukan token lain, ia memanggil pengimbas. Apabila menerima serpihan perwakilan perantaraan, panggilan dibuat kepada penjana kod. Penyelesaian proses terjemahan berlaku selepas token terakhir diterima dan diproses dan dimulakan oleh penghurai.

Kelebihan skim satu laluan termasuk ketiadaan volum besar data perantaraan, kelajuan pemprosesan yang tinggi disebabkan oleh gabungan fasa dalam satu proses, dan ketiadaan akses kepada peranti storan luaran.

Kelemahan termasuk: kemustahilan melaksanakan skema terjemahan sedemikian untuk bahasa dengan struktur kompleks dan kekurangan data perantaraan yang boleh digunakan untuk analisis dan pengoptimuman yang kompleks.

Skim ini sering digunakan untuk bahasa pengaturcaraan yang mudah dalam struktur semantik dan sintaksis, baik dalam penyusun dan jurubahasa. Contoh bahasa tersebut ialah Asas dan Pascal. Jurubahasa klasik biasanya dibina menggunakan skema satu laluan, kerana pelaksanaan langsung dijalankan pada tahap serpihan individu perwakilan perantaraan. Organisasi interaksi antara blok penterjemah sedemikian ditunjukkan dalam Rajah. 1.10.

Interaksi gabungan blok penterjemah

Gabungan skim terjemahan berbilang laluan dan satu laluan menimbulkan pelbagai pilihan gabungan, kebanyakannya berjaya digunakan. Sebagai contoh, kita boleh mempertimbangkan sebahagian daripada mereka.

Dalam Rajah. Rajah 1.11 menunjukkan gambar rajah interaksi blok penterjemah, membahagikan keseluruhan proses kepada dua laluan. Pas pertama menjana perwakilan perantaraan lengkap program, dan yang kedua menjana kod. Menggunakan skema sedemikian membolehkan anda dengan mudah memindahkan penterjemah dari satu sistem komputer ke yang lain dengan menulis semula penjana kod.

Di samping itu, bukannya penjana kod, mudah untuk menyambungkan emulator perwakilan perantaraan, yang cukup mudah membolehkan anda membangunkan sistem pengaturcaraan dalam bahasa tertentu, berorientasikan kepada pelbagai persekitaran pelaksanaan. Contoh organisasi interaksi antara blok penterjemah ditunjukkan dalam Rajah. 1.12.

Bersama-sama dengan skim yang melibatkan penggantian penjana kod dengan emulator, terdapat penterjemah yang membenarkannya perkongsian. Salah satu daripada skema tersebut ditunjukkan dalam Rajah. 1.13.

Proses penterjemahan, termasuk penjanaan kod, boleh diselesaikan dalam sebarang bilangan pas (contohnya menggunakan terjemahan laluan tunggal yang dibentangkan sebelum ini). Walau bagaimanapun, kod objek yang dijana tidak dilaksanakan pada sistem komputer yang sepadan, tetapi dicontohi pada komputer dengan seni bina yang berbeza. Skim ini digunakan dalam persekitaran yang dibina di sekeliling bahasa pengaturcaraan Java. Penterjemah itu sendiri menjana kod mesin maya Java, emulasi yang dijalankan dengan cara khas secara autonomi dan dalam persekitaran pelayar Internet.

Skim yang dibentangkan juga boleh mempunyai tafsiran yang lebih luas berhubung dengan mana-mana pengkompil yang menjana kod mesin. Masalahnya ialah kebanyakan komputer moden dilaksanakan menggunakan kawalan mikroprogram. Peranti kawalan program mikro boleh dianggap sebagai program yang meniru kod mesin. Ini membolehkan kita bercakap tentang penggunaan meluas skim terkini yang dibentangkan.

Soalan ujian dan tugasan

Namakan perbezaan:

jurubahasa daripada penyusun;
pengkompil daripada penghimpun;
transkoder penterjemah;
emulator daripada penterjemah;
sintaks daripada semantik.

Beritahu kami tentang perkembangan terkini dalam bahasa pengaturcaraan yang anda ketahui. Berikan ciri-ciri utama bahasa-bahasa tersebut.
bawa contoh khusus penggunaan kaedah terjemahan dalam bidang yang tidak berkaitan dengan bahasa pengaturcaraan.
Berikan contoh khusus bahasa pengaturcaraan yang disusun.
Berikan contoh khusus bahasa pengaturcaraan yang ditafsirkan.
Berikan contoh khusus bahasa pengaturcaraan di mana kedua-dua penyusun dan jurubahasa tersedia.
Kelebihan dan kekurangan utama penyusun.
Kelebihan dan kekurangan utama jurubahasa.
Terangkan perbezaan utama dalam sintaks dua bahasa pengaturcaraan yang anda tahu.
Terangkan perbezaan utama dalam semantik dua bahasa pengaturcaraan yang anda tahu.
Namakan fasa utama proses terjemahan dan tujuannya.
Namakan ciri khusus terjemahan satu laluan.
Namakan ciri khusus terjemahan berbilang laluan.
Berikan contoh kemungkinan gabungan terjemahan satu laluan dan berbilang laluan. Beritahu kami tentang kegunaan praktikal skim-skim ini.

Bahasa pengaturcaraan boleh dibahagikan kepada disusun dan ditafsirkan.

Satu atur cara dalam bahasa yang disusun, menggunakan atur cara pengkompil khas, ditukar (disusun) menjadi satu set arahan untuk jenis pemproses tertentu (kod mesin) dan kemudian ditulis ke dalam modul boleh laku, yang boleh dilancarkan untuk pelaksanaan sebagai program berasingan. Dengan kata lain, pengkompil menterjemahkan kod sumber program daripada bahasa pengaturcaraan peringkat tinggi kepada kod binari arahan pemproses.

Jika program ditulis dalam bahasa yang ditafsirkan, maka jurubahasa secara langsung melaksanakan (mentafsir) teks sumber tanpa terjemahan terlebih dahulu. Dalam kes ini, program ini kekal dalam bahasa asal dan tidak boleh dilancarkan tanpa jurubahasa. Kita boleh mengatakan bahawa pemproses komputer ialah penterjemah kod mesin.

Ringkasnya, pengkompil menterjemahkan kod sumber program ke dalam bahasa mesin serta-merta dan secara keseluruhannya, sambil mencipta program boleh laksana, dan jurubahasa melaksanakan teks sumber secara langsung semasa pelaksanaan program.

Pembahagian kepada bahasa yang disusun dan ditafsirkan agak sewenang-wenangnya. Jadi, untuk mana-mana bahasa yang disusun secara tradisional, seperti Pascal, anda boleh menulis penterjemah. Di samping itu, kebanyakan jurubahasa "tulen" moden tidak melaksanakan binaan bahasa secara langsung, sebaliknya menyusunnya menjadi beberapa perwakilan pertengahan peringkat tinggi (contohnya, dengan penyahrujukan berubah-ubah dan pengembangan makro).

Pengkompil boleh dibuat untuk mana-mana bahasa yang ditafsirkan - contohnya, bahasa Lisp, yang ditafsirkan secara asli, boleh disusun tanpa sebarang sekatan. Kod yang dijana semasa pelaksanaan program juga boleh disusun secara dinamik semasa pelaksanaan.

Sebagai peraturan, atur cara yang disusun melaksanakan lebih cepat dan tidak memerlukan program tambahan untuk dilaksanakan, kerana ia telah diterjemahkan ke dalam bahasa mesin. Pada masa yang sama, setiap kali teks program ditukar, ia perlu disusun semula, yang menimbulkan kesukaran semasa pembangunan. Di samping itu, program yang disusun hanya boleh dilaksanakan pada jenis komputer yang sama, dan biasanya di bawah sistem pengendalian yang sama, yang mana pengkompil telah direka bentuk. Untuk mencipta boleh laku untuk jenis mesin yang berbeza, kompilasi baharu diperlukan.

Bahasa yang ditafsirkan mempunyai beberapa khusus ciri-ciri tambahan(lihat di atas), sebagai tambahan, program mengenainya boleh dilancarkan serta-merta selepas perubahan, yang memudahkan pembangunan. Program dalam bahasa yang ditafsirkan selalunya boleh dijalankan jenis yang berbeza kereta dan sistem operasi tanpa usaha tambahan.

Walau bagaimanapun, program yang ditafsir berjalan dengan ketara lebih perlahan daripada yang disusun, dan ia tidak boleh dilaksanakan tanpa program penterjemah tambahan.

Sesetengah bahasa, seperti Java dan C#, termasuk di antara disusun dan ditafsirkan. Iaitu, program ini tidak disusun ke dalam bahasa mesin, tetapi ke dalam kod bebas mesin peringkat rendah, bytecode. Bytecode kemudiannya dilaksanakan oleh mesin maya. Tafsiran biasanya digunakan untuk melaksanakan kod bait, walaupun bahagian individu boleh diterjemahkan ke dalam kod mesin secara langsung semasa pelaksanaan program menggunakan kompilasi Just-in-time (JIT) untuk mempercepatkan atur cara. Untuk Java, bytecode dilaksanakan oleh Java Virtual Machine (JVM), untuk C# - oleh Common Language Runtime.

Pendekatan ini, dalam erti kata lain, membolehkan anda menggunakan kelebihan kedua-dua jurubahasa dan penyusun. Ia juga bernilai menyebut bahasa Forth asal, yang mempunyai kedua-dua jurubahasa dan penyusun.

Memandangkan teks yang ditulis dalam bahasa pengaturcaraan tidak dapat difahami oleh komputer, ia perlu diterjemahkan ke dalam kod mesin. Terjemahan program sedemikian daripada bahasa pengaturcaraan kepada bahasa kod mesin dipanggil terjemahan, dan ia dilakukan program khas- penterjemah.

Penterjemah ialah program perkhidmatan yang menukar program sumber yang disediakan dalam bahasa pengaturcaraan input kepada program kerja yang dibentangkan dalam bahasa objek.

Pada masa ini, penterjemah dibahagikan kepada tiga kumpulan utama: penghimpun, penyusun dan jurubahasa.

Penghimpun ialah program utiliti sistem yang menukar struktur simbolik kepada arahan bahasa mesin. Ciri khusus pemasang ialah mereka melaksanakan terjemahan verbatim satu arahan simbolik ke dalam satu arahan mesin. Oleh itu, bahasa himpunan (juga dipanggil autokod) direka untuk memudahkan persepsi sistem arahan komputer dan mempercepatkan pengaturcaraan dalam sistem arahan ini. Adalah lebih mudah bagi seorang pengaturcara untuk mengingati penunjuk mnemonik arahan mesin daripada kod binari mereka.

Pengkompil ialah program perkhidmatan yang menterjemahkan atur cara yang ditulis dalam bahasa pengaturcaraan sumber ke dalam bahasa mesin. Sama seperti penghimpun, pengkompil menukar atur cara daripada satu bahasa ke bahasa lain (paling kerap, ke dalam bahasa komputer tertentu). Pada masa yang sama, arahan bahasa sumber berbeza dengan ketara dalam organisasi dan kuasa daripada arahan bahasa mesin. Terdapat bahasa di mana satu arahan bahasa sumber diterjemahkan ke dalam 7-10 arahan mesin. Walau bagaimanapun, terdapat juga bahasa di mana setiap arahan boleh mempunyai 100 atau lebih arahan mesin (contohnya, Prolog). Di samping itu, bahasa sumber sering menggunakan penaipan data yang ketat, dilakukan melalui penerangan awal mereka. Pengaturcaraan mungkin tidak bergantung pada pengekodan algoritma, tetapi pada pemikiran dengan teliti tentang struktur data atau kelas. Proses penterjemahan daripada bahasa tersebut biasanya dipanggil kompilasi, dan bahasa sumber biasanya diklasifikasikan sebagai bahasa pengaturcaraan peringkat tinggi (atau bahasa peringkat tinggi). Abstraksi bahasa pengaturcaraan daripada sistem arahan komputer membawa kepada penciptaan bebas pelbagai bahasa yang memberi tumpuan kepada menyelesaikan masalah tertentu. Bahasa telah muncul untuk pengiraan saintifik, pengiraan ekonomi, akses kepada pangkalan data, dan lain-lain.

Jurubahasa - program atau peranti yang menjalankan terjemahan operator demi operator dan pelaksanaan program sumber. Tidak seperti pengkompil, penterjemah tidak menghasilkan program bahasa mesin sebagai output. Setelah mengenali arahan dalam bahasa sumber, ia segera melaksanakannya. Kedua-dua penyusun dan jurubahasa menggunakan kaedah yang sama untuk menganalisis kod sumber program. Tetapi jurubahasa membenarkan anda untuk mula memproses data selepas menulis walaupun satu arahan. Ini menjadikan proses pembangunan dan penyahpepijatan program lebih fleksibel. Di samping itu, ketiadaan kod mesin keluaran memungkinkan untuk tidak "menghancurkan" peranti luaran dengan fail tambahan, dan penterjemah itu sendiri boleh dengan mudah disesuaikan dengan mana-mana seni bina mesin, setelah membangunkannya sekali sahaja dalam bahasa pengaturcaraan yang digunakan secara meluas. Oleh itu, bahasa yang ditafsirkan seperti Skrip Java dan Skrip VB telah meluas. Kelemahan jurubahasa adalah kelajuan rendah pelaksanaan program. Biasanya, program yang ditafsir berjalan 50 hingga 100 kali lebih perlahan daripada program asli.

Emulator ialah program atau perisian dan alat perkakasan yang menyediakan keupayaan, tanpa pengaturcaraan semula, untuk melaksanakan pada komputer tertentu program yang menggunakan kod atau kaedah melaksanakan operasi yang berbeza daripada komputer yang diberikan. Emulator adalah serupa dengan penterjemah kerana ia melaksanakan secara langsung atur cara yang ditulis dalam bahasa tertentu. Walau bagaimanapun, selalunya ia adalah bahasa mesin atau kod perantaraan. Kedua-duanya mewakili arahan dalam kod binari yang boleh dilaksanakan serta-merta selepas kod operasi diiktiraf. Tidak seperti program teks, tidak perlu mengenali struktur program atau memilih operan.

Emulator digunakan agak kerap untuk pelbagai tujuan. Sebagai contoh, apabila membangunkan sistem pengkomputeran baharu, emulator pertama kali dicipta yang menjalankan program yang dibangunkan untuk komputer yang belum wujud. Ini membolehkan anda menilai sistem arahan dan membangunkan perisian asas walaupun sebelum perkakasan yang sepadan dicipta.

Selalunya, emulator digunakan untuk menjalankan program lama pada komputer baharu. Biasanya, komputer yang lebih baharu adalah lebih pantas dan mempunyai peranti yang lebih baik. Ini membolehkan anda meniru program lama dengan lebih cekap daripada menjalankannya pada komputer lama.

Transcoder ialah program atau peranti perisian yang menterjemahkan atur cara yang ditulis dalam bahasa mesin satu komputer kepada atur cara dalam bahasa mesin komputer lain. Jika emulator adalah analog penterjemah yang kurang pintar, maka transcoder bertindak dalam kapasiti yang sama berhubung dengan pengkompil. Begitu juga, kod mesin sumber (dan biasanya binari) atau perwakilan perantaraan ditukar kepada kod lain yang serupa dengan satu arahan dan tanpa sebarang analisis umum struktur program sumber. Transkoder berguna apabila memindahkan atur cara dari satu seni bina komputer ke yang lain. Ia juga boleh digunakan untuk membina semula teks program bahasa peringkat tinggi daripada kod binari sedia ada.

Makropemproses ialah program yang menggantikan satu jujukan aksara dengan yang lain. Ini adalah jenis penyusun. Ia menjana teks output dengan memproses sisipan khas yang terletak dalam teks sumber. Sisipan ini direka bentuk dengan cara yang istimewa dan tergolong dalam binaan bahasa yang dipanggil makrolanguage. Makropemproses sering digunakan sebagai alat tambah kepada bahasa pengaturcaraan, meningkatkan fungsi sistem pengaturcaraan. Hampir mana-mana pemasang mengandungi makropemproses, yang meningkatkan kecekapan membangunkan program mesin. Sistem pengaturcaraan sedemikian biasanya dipanggil macroassemblers.

Sintaksis ialah satu set peraturan bahasa yang menentukan pembentukan unsur-unsurnya. Dalam erti kata lain, ini adalah satu set peraturan untuk pembentukan urutan simbol yang signifikan secara semantik dalam bahasa tertentu. Sintaks ditentukan menggunakan peraturan yang menerangkan konsep bahasa. Contoh konsep ialah: pembolehubah, ungkapan, pengendali, prosedur. Urutan konsep dan penggunaannya yang boleh diterima dalam peraturan menentukan struktur yang betul secara sintaksis yang membentuk atur cara. Ia adalah hierarki objek, dan bukan cara mereka berinteraksi antara satu sama lain, yang ditakrifkan melalui sintaks. Sebagai contoh, pernyataan hanya boleh berlaku dalam prosedur, ungkapan dalam pernyataan, pembolehubah boleh terdiri daripada nama dan indeks pilihan, dsb. Sintaks tidak dikaitkan dengan fenomena sedemikian dalam program sebagai "melompat ke label yang tidak wujud" atau "pembolehubah dengan nama yang diberikan tidak ditakrifkan." Inilah yang dilakukan oleh semantik.

Semantik - peraturan dan syarat yang menentukan hubungan antara unsur bahasa dan makna semantiknya, serta tafsiran makna bermakna binaan sintaksis bahasa. Objek bahasa pengaturcaraan bukan sahaja diletakkan dalam teks mengikut hierarki tertentu, tetapi juga saling berkaitan melalui konsep lain yang membentuk pelbagai persatuan. Sebagai contoh, pembolehubah, yang sintaksnya mentakrifkan lokasi yang sah hanya dalam pengisytiharan dan beberapa pernyataan, mempunyai jenis tertentu, boleh digunakan dengan bilangan operasi yang terhad, mempunyai alamat, saiz, dan mesti diisytiharkan sebelum ia boleh. digunakan dalam program.

Parser ialah komponen pengkompil yang menyemak penyataan sumber untuk pematuhan dengan peraturan sintaksis dan semantik bahasa pengaturcaraan tertentu. Walaupun namanya, penganalisis menyemak kedua-dua sintaks dan semantik. Ia terdiri daripada beberapa blok, setiap satunya menyelesaikan masalahnya sendiri. Ia akan dibincangkan dengan lebih terperinci apabila menerangkan struktur penterjemah. pengaturcaraan bahasa penyusun penterjemah

Mana-mana penterjemah melaksanakan tugas utama berikut:

- menganalisis program yang diterjemahkan, khususnya menentukan sama ada ia mengandungi ralat sintaks;
- menjana program keluaran (sering dipanggil program objek) dalam bahasa arahan mesin;
- memperuntukkan ingatan untuk atur cara objek.1.1 Jurubahasa

Satu kelebihan yang sering disebut dalam pelaksanaan tafsiran ialah ia membenarkan "mod segera". Mod langsung membolehkan anda meminta komputer tugasan seperti PRINT 3.14159*3/2.1 dan mengembalikan jawapan kepada anda sebaik sahaja anda menekan Masukkan kunci(ini membolehkan komputer $3,000 digunakan sebagai kalkulator $10). Selain itu, jurubahasa mempunyai atribut khas yang memudahkan penyahpepijatan. Anda boleh, sebagai contoh, mengganggu pemprosesan program penterjemah, memaparkan kandungan pembolehubah tertentu, meluncurkan program, dan kemudian meneruskan pelaksanaan.

Perkara yang paling disukai oleh pengaturcara tentang jurubahasa ialah keupayaan untuk mendapatkan jawapan yang pantas. Tidak ada keperluan untuk kompilasi di sini, kerana jurubahasa sentiasa bersedia untuk mengganggu program anda. Taip RUN dan hasil perubahan terbaharu anda muncul pada skrin.

Walau bagaimanapun, bahasa penterjemah mempunyai kelemahan. Adalah perlu, sebagai contoh, untuk mempunyai salinan penterjemah dalam ingatan pada setiap masa, manakala banyak keupayaan jurubahasa, dan oleh itu keupayaannya, mungkin tidak diperlukan untuk pelaksanaan program tertentu.

Kelemahan halus jurubahasa ialah mereka cenderung untuk tidak menggalakkan gaya pengaturcaraan yang baik. Memandangkan komen dan butiran rasmi lain menggunakan sejumlah besar memori program, orang ramai cenderung untuk tidak menggunakannya. Syaitan kurang marah daripada seorang pengaturcara yang bekerja dalam jurubahasa BASIC yang cuba memasukkan program 120K ke dalam memori 60K. tetapi perkara yang paling teruk ialah jurubahasa bergerak perlahan.

Mereka menghabiskan terlalu banyak masa untuk memikirkan apa yang perlu dilakukan dan bukannya melakukan kerja. Ketika membuat persembahan pengendali program, jurubahasa mesti terlebih dahulu mengimbas setiap pernyataan untuk membaca kandungannya (apa yang orang ini minta saya lakukan?) dan kemudian melaksanakan operasi yang diminta. Operator dalam gelung diimbas secara berlebihan.

Pertimbangkan atur cara: dalam penterjemah BASIC 10 UNTUK N=1 HINGGA 1000 20 CETAK N,SQR(N) 30 SETERUSNYA N kali pertama anda melalui program ini, Jurubahasa ASAS mesti memikirkan maksud baris 20:

1. tukarkan pembolehubah berangka N kepada rentetan
2. hantar rentetan ke skrin
3. beralih ke kawasan cetakan seterusnya
4. hitung punca kuasa dua N
5. tukarkan hasilnya kepada rentetan
6. hantar rentetan ke skrin

Semasa laluan kedua kitaran, semua penyelesaian ini diulang lagi, kerana semua hasil kajian garis ini beberapa milisaat yang lalu telah dilupakan sepenuhnya. Dan seterusnya untuk semua 998 pas seterusnya. Jelas sekali, jika anda dapat memisahkan fasa pengimbasan/pemahaman daripada fasa pelaksanaan, anda akan mempunyai lebih banyak program cepat. Dan inilah sebenarnya yang digunakan oleh penyusun.

Rahsia saya

Jenis-jenis penterjemah

Perlaksanaan

Hantar kerja baik anda di pangkalan pengetahuan adalah mudah. Gunakan borang di bawah

1.1 Analisis atas ke bawah

1.2 Analisis bawah ke atas

1.2.1 LR(k) - tatabahasa

1.2.1.1 LR(0) - tatabahasa

1.2.2 LALR(1) - tatabahasa

2. Pembangunan penterjemah

2.1 Analisis keperluan

2.2 Reka bentuk

2.2.1 Mereka bentuk penganalisis leksikal

2.2.4 Pelaksanaan perisian parser

2.3 Pengekodan

2.4 Pengujian

Kesimpulan

Senarai sumber yang digunakan

Lampiran A. Penyenaraian teks program penterjemah

Lampiran B. Keputusan ujian

Lampiran B. Gambarajah atur cara penterjemah

pengenalan

Bahasa pengaturcaraan agak berbeza antara satu sama lain dalam tujuan, struktur, kerumitan semantik, dan kaedah pelaksanaan. Ini mengenakan ciri khususnya sendiri pada pembangunan penterjemah tertentu.

Pada masa yang sama, semua bahasa pengaturcaraan mempunyai beberapa ciri umum dan parameter. Kesamaan ini juga menentukan prinsip penyusunan penterjemah yang serupa untuk semua bahasa.

Bahasa pengaturcaraan direka untuk memudahkan pengaturcaraan. Oleh itu, pengendali dan struktur data mereka lebih berkuasa daripada dalam bahasa mesin.

Untuk meningkatkan keterlihatan program, bukannya kod angka, representasi simbolik atau grafik bagi binaan bahasa digunakan, yang lebih mudah untuk persepsi manusia.

Untuk mana-mana bahasa ia ditakrifkan:

- banyak simbol yang boleh digunakan untuk menulis atur cara yang betul (abjad), elemen asas,

- banyak program yang betul (sintaks),

- "makna" setiap program yang betul (semantik).

Secara formal, masing-masing program yang betul X ialah rentetan aksara daripada beberapa abjad A, ditukar kepada rentetan Y yang sepadan, terdiri daripada aksara daripada abjad B.

Dalam hal ini, ciri umum berikut boleh dibezakan tambahan untuk semua bahasa dan programnya: setiap bahasa mesti mengandungi peraturan yang membenarkan menjana program yang sepadan dengan bahasa ini atau mengiktiraf surat-menyurat antara program bertulis dan bahasa tertentu.

Tujuan kerja kursus ini adalah untuk membangunkan penterjemah pendidikan daripada yang dipermudahkan bahasa teks tahap tinggi.

1. Kaedah analisis tatabahasa

Mari kita lihat kaedah asas penghuraian tatabahasa.

1.1 Analisis atas ke bawah

1.1.1 LL(k) - bahasa dan tatabahasa

Pertimbangkan pokok inferens dalam proses mendapatkan keluaran kiri rantai. Rantai perantaraan dalam proses inferens terdiri daripada rantaian terminal w, paling kiri bukan terminal A, bahagian bawah inferens x:

-S--

/ \

/ -A-x-\

/ | \

-w---u----

Rajah 1

Mari kita tentukan dua set rantai:

a) FIRST(x) ialah set rentetan terminal yang diterbitkan daripada x, dipendekkan kepada k aksara.

b) FOLLOW(A) - satu set rantai terminal dipendekkan kepada aksara k, yang boleh mengikuti A dengan segera dalam rantai output.

Tatabahasa mempunyai sifat LL(k) jika, daripada kewujudan dua rantai inferens kiri:

S:: wAx: wzx:: wu

S:: wAx: wtx:: wv

daripada keadaan FIRST(u)=FIRST(v) ia mengikuti z=t.

Dalam kes k=1, untuk memilih peraturan untuk A, cukup untuk mengetahui hanya bukan terminal A dan a - aksara pertama rantai u:

- peraturan A:x harus dipilih jika a disertakan dalam FIRST(x),

- peraturan A:e hendaklah dipilih jika a disertakan dalam FOLLOW(A).

Sifat LL(k) mengenakan sekatan yang agak kuat pada tatabahasa. Contohnya, tatabahasa LL(2) S: aS | a tidak mempunyai harta LL(1), kerana PERTAMA(aS)=PERTAMA(a)=a. Dalam kes ini, anda boleh mengurangkan nilai k menggunakan "pemfaktoran" (mengambil faktor daripada kurungan):

S: aA

A: S | e

1.1.2 Kaedah penurunan rekursif

Kaedah turunan rekursif ditujukan kepada kes apabila pengkompil diprogramkan dalam salah satu bahasa peringkat tinggi, apabila penggunaan prosedur rekursif dibenarkan.

Idea utama keturunan rekursif ialah setiap nonterminal tatabahasa mempunyai prosedur yang sepadan yang mengiktiraf mana-mana rantai yang dihasilkan oleh bukan terminal ini. Prosedur ini memanggil satu sama lain apabila diperlukan.

Kod mana-mana peraturan mengandungi operasi untuk setiap aksara yang disertakan dalam sebelah kanan peraturan. Operasi disusun mengikut susunan simbol muncul dalam peraturan. Berikutan operasi terakhir, kod tersebut mengandungi pulangan daripada prosedur.

Menggunakan turunan rekursif dalam bahasa peringkat tinggi menjadikan pengaturcaraan dan penyahpepijatan lebih mudah.

1.2 Analisis bawah ke atas

Mari kita pertimbangkan penghuraian bawah ke atas, di mana pin perantaraan digerakkan di sepanjang pokok ke arah akar. Jika anda membaca aksara dalam rentetan dari kiri ke kanan, pokok parse akan kelihatan seperti ini:

-S--

/ \

/-x-\

/ | \

--w--b--u-

Rajah 2

-S-- -S--

/ \ / \

/-x-b-\ /yB-\

/ | \ / | \

--w--b--u- --w--b--u-

Rajah 3 - Selepas syif Rajah 4 - Selepas lilitan

Jika lilitan digunakan hanya untuk aksara terakhir x, maka kami akan menerima output rantaian yang betul. Penghuraian ini dipanggil LR, di mana simbol L (Kiri, kiri) merujuk kepada melihat rantai dari kiri ke kanan, dan R (Kanan, kanan) merujuk kepada output yang terhasil.

Urutan operasi anjakan dan lipatan adalah penting. Oleh itu, penghuraian deterministik memerlukan pemilihan antara anjakan dan lilitan (dan peraturan lilitan yang berbeza) pada setiap saat.

1.2.1 LR(k) - tatabahasa

-S--