FI111107B - Menetelmä translaattorin kehittämiseksi ja vastaava järjestelmä - Google Patents

Description

111107 MENETELMÄ TRANSLAATTORIN KEHITTÄMISEKSI JA VASTAAVA JÄRJESTELMÄ

Keksinnön kohteena on menetelmä translaattorin kehittämiseksi ja vastaava järjestelmä, joka on tarkoitettu konvertoimaan tulokielisen koodin lähtökieliseksi. Menetelmässä käytetään kuvauskieltä (V) 5 kahden toisistaan riippumattoman lähdekielen, nimittäin sanottujen tulokielen (X) ja lähtökielen (Y) formaaliin kuvaamiseen kunkin lähdekielen käsittäessä formaalisia termejä (Xi,Yj) ja kussakin pääter-missä yksi tai useampia esiintymiä ja näissä mahdollisia parametrejä.

Jokainen formaali kieli, joita ovat mm. kaikki ohjelmointikielet ja formaalit spesifiointikielet, on määriteltä-10 vissä sen lauseiden eli rakenteiden avulla yksiselitteisesti siten, että määritellään kunkin lauseen mahdolliset lausetyypit ja sen alalauseiden tyypit sekä lisäksi kielen ulkoasu (syntaksi), joka sisältää avainsanat ja määrittää sanojen ja termien kiinteän järjestyksen. Kukin termi voi olla varattu sana, kuten jakamaton termi (T) tai käsitteellinen tyyppi (C) tai jaollinen termi (N), joka on korkeampi komponentti ja rakennettu muista tyypeistä. Korkeinta termiä kutsutaan käynnistyssymboliksi (S). Kullakin termityypillä 15 on nimi, produktio (P) eli päätermi. Produktio voi olla joko lista (L), jaollinen termi (N), jaoton termi (T) tai tiettyä tyyppiä (C). Formaali kielioppi on yhdistelmä näistä kaikista (S,P,T,N,C,L). Koko kielioppi voidaan muodostaa lähtien käynnistyssymbolista käyttäen tyypillistä puun läpikäyntirutiinia, joka päättyy jaottomiin termeihin, jotka ovat puun lehtiä.

20 Yleinen translaatioperiaate voidaan kuvata seuraavasti. Koodin lukeminen tapahtuu skanneritoiminnolla, joka jakaa koodin avaintermeiksi (token list). Avaintermit ryhmitellään jäsennys-toiminnolla jäsennys-puuksi ja tämä puretaan yksittäisiksi termeiksi, joiden käsittelyyn luodaan omat säännöt. Tunnetuissa konversioprosesseissa kielestä toiseen perustermit eli avainsanat löydetään joko kielen sanastosta (varatut sanat), sen kirjastoista.

25

Lausekielen komennot jaetaan tyypillisesti perättäisrakenteisiin, ohjausrakenteisiin, valintarakenteisiin ja tietorakenteisiin.

Perättäisrakenteet ovat konversion kannalta suoraviivaisia ja niille kehitetään vastaavuudet lauseke ja 30 termi kerrallaan. Ohjausrakennekonversiot rikkaampaan kieleen päin ovat yksinkertaisia, sillä vastaavuus voidaan kehittää suoraan tai pienellä muunnostyöllä. Ohjausrakennekonversio suppeampaan kieleen edellyttää manuaalista tarkistusta siinä tapauksessa että käytetään uudesta kielestä puuttuvia rakenteita. Esimerkiksi C:n for-silmukan muuttaminen Pascalin for-silmukaksi ei onnistu sellaisenaan, jos silmukan ohjausosissa (inkrementointi, päätösosa) on muita kuin perusinkrementointiin tai -dekre- * i 35 mentointiin liittyviä toimintoja. Siten Pascalin vastaavuudeksi kannattaisi määritellä esim. “REPEAT-UNTIL”-silmukka sopivasti täydennettynä.

Valintarakenteet eri ohjelmointikielissä muistuttavat toisiaan. Tietorakenteet tehdään yhteen sopiviksi kirjastoja ja määriteltyjä funktiokutsuja tai makroja käyttäen. Dynaamisen muistin käsittelyssä muodoste-40 taan funktiovastaavuudet kielten välille.

2 111107

Tunnettu tapa translaattorien tekemiseen perustuu Abstract syntax tree -periaatteeseen (AST) tai Olio-Framework -periaatteeseen (OF). AST sisältää tulokielen kieliopin, spesifiset ohjelmistorakenteet ja sääntöesitysmuodon, jolla tulokieltä muutetaan lähtökieleksi. OF-periaatteessa tulokielen termejä vastaamaan luodaan oliot ja luokat, joihin kirjoitetaan koodi uutta kieltä ja sen termejä varten. OF:n 5 luokissa sijaitsee myös koodi, joka suorittaa kyseisen luokan jäsennystoiminnon hajautetusti. Edellä kuvatuissa menetelmissä kielten välinen yhteys tapahtuu syntaksipuuna. Tunnettuja tapoja on kuvattu mm. seuraavissa patenteissa: EP 0371943, EP 0371944, US 5,768,564 ja US 4,980,829 ja US 4,729,096 sekä GB 2327786. Kaikki tunnetut translaattorit johtavat varsin raskaisiin sovelluksiin. Käännettäessä samaa kieltä usealle kielelle lähtökielen prosessointimäärää on pystytty pienentämään 10 eräissä tapauksissa. Edellä mainitun EP-julkaisujen mukaisissa ratkaisuissa lähtökielisen koodin sanallinen skannaus ja jäsennysprosessit pyritään erottamaan varsinaisesta kääntämisestä. Julkaisun mukaan kehitetyillä tiedostoilla kääntäjä konvertoi input-tiedoston suoraan lähtökieliseksi koodiksi.

Tämän keksinnön tarkoituksena on luoda aikaisempaa yksinkertaisempi menetelmä translaattorin 15 kehittämiseksi ja vastaava järjestelmä. Keksinnön mukaisen menetelmä tunnusmerkilliset piirteet on esitetty oheisessa patenttivaatimuksessa 1 ja vastaavan järjestelmän tunnusmerkilliset piirteet on esitetty patenttivaatimuksessa 6. Menetelmän mukaan kummankin kielen rakenne kuvataan kielioppina ja samalla jokaiselle termille valitaan sopiva semanttinen nimi, joka vastaa syntaksirakennetta. Konversio tehdään semanttisella tasolla siten, että molemmista lähdekielistä karsitaan epäoleellinen syntaksi-20 tieto pois muodostamalla näistä kuvauskielet muunnokset. Samalla näistä saaduista tiedoista ja lähdekielistä voidaan muodostaa translaattorille tarvittavat aputiedostot, jolloin kehitetty translaattori muodostaa jäsennyspuun sanotulla kuvauskielellä, jonka konvertoiminen on nyt mahdollista suorittaa minimitietämystä käyttäen. Samoin tällaisen konversio-ohjeen muodostaminen kullekin lähtökielen termille ja sen esiintymälle on työmäärältään huomattavasti pienempi kuin tunnetuilla translaattoreilla.

2 5 Kuvauskielisten muunnosten tekeminen on melko suoraviivainen toimenpide ja se tapahtuu edullisesti jo kieliopin sisäänkirjoitusvaiheessa. Niiden avulla yhdessä formaalien alkuperäisten kielioppien avulla •' muodostetaan automaattisesti translaattorin käyttämät aputiedostot.

Keksinnöllä saadaan seuraavia etuja: 30

Sovellettaessa menetelmää useiden kielien välillä, erityisesti yhdestä kielestä useampaan kieleen, saadaan huomattavaa etua, kun tulokieli tarvitsee muuntaa vain kerran kuvauskielelle.

3 5 - Itse translaattorista muodostuu varsin kevyt ohjelma ja sen käyttämä konversio-ohjetie dosto on pienin mahdollinen. Kuten edellä todettiin, aputiedostot kasvattavat tietomäärää jonkin verran, mutta ne ovat varsin suoraviivaisesti rakennettuja listoja. Keksinnön mukainen menetelmä antaa mahdollisuuden testata menetelmää muuntamalla välikielelle käännetty ohjelmakoodi takaisin tulokielelle.

40 3 111107 Lähtökieli voi olla myös ohjelmointikielen sijasta dokumentaatiokieli, erityisesti XML-formaatti. Tämä mahdollistaa automaattisen dokumentoinnin. Lähtökieli on valitun muotoinen dokumentointiformaatti, (esim.modulilistaus, muuttujaluettelo, ristiviitetaulu, • graafinen hierarkiakaavio, tiedonkulkukaavio.).

5 • Seuraavassa keksintöä kuvataan esimerkin avulla, joka on esitetty oheisissa kuvissa ja koodilistauksis-sa. Esimerkissä kuvataan translaattorin kehittäminen yksinkertaisesta Minilan-kielestä C-kieleen. Minilan-kielen kielioppi on selostettu sivulla 12 ja tarvittavat näytteet C-kielen kieliopista sivulla 19.

10 Kuva 1 esittää vuokaaviota keksinnön mukaisesta menetelmästä translaattorin kehittämiseksi. Kuva 2 esittää vuokaaviota translaattorin toiminnasta.

Kuvat 3 ja 4 esittävät graafista käyttöliittymää interaktiivista kytkentää varten Kuva 5 esittää Minilan-kielen semanttista puurakennetta linkkeineen C-kieleen.

Kuvat 6a- 6g esittävät get-lauseiden toimintaa translaattorissa 15 Kuvat 7a- 7h esittävät gen- ja muotoilulauseiden toimintaa translaattorissa

Keksinnön mukainen menetelmä soveltuu kahden mielivaltaisen formaalin lähdekielen välisen translaattorin kehitykseen. Kuvassa 1 ensimmäinen lähdekieli on tulokieli X ja toinen lähdekieli on lähtökieli Y. Ensimmäisessä vaiheessa näiden kieliopit on tallennettava formaalisti tietokantaan, vaiheet 1 ja 1'. 20 Menetelmän toteuttamiseksi tarvitaan tietokonejärjestelmä ohjelmistoineen,, josta myöhemmin käytetään nimitystä transaattorikehitin. Oheisissa esimerkeissä on esitelty eräs edullinen formaatti, jonka mukaan varatut sanat kirjoitetaan pienellä ja osiin jaettavat (määritellyt = non-terminals) termit isolla ja tietyt termit korvataan valituilla merkeillä ja sanoilla, mm. V on “plus", “=” on “eq”, “<“ on “It" ja piste on “dof Tässä esitetyssä esimerkissä käytetään tulokielenä suppeaa Minilan-kieltä ja lähtökielenä C-kieltä. 25

Seuraavassa vaiheessa muodostetaan kuvauskielinen muunnos, tässä tyypitettävälle PROLOG-kielelle, joskin jokin muukin tyypittävä, assosiatiivinen ja semanttinen kuvaus tulee kyseeseen, vaiheet 2 ja 2\ Prolog-kieltä on kuvattu seuraavissa julkaisuissa: “Programming in Prolog”, 1984; W.F.CIocks C.S. Mellish (ISBN 3-540-15011-0 ISBN 0-387-15011-0) ja “Visual Prolog Perusteet”, 1995; Erkki Laitila, 30 (ISBN-952-9823-51-7). Edullisimmin käytetään Visual Prolog-kehitintä (Prolog Development Center, DK), jossa on tarvittava päättelykone sisäänrakennettuna.

.. Vaikka molempien kielten termit muunnetaan samojen sääntöjen mukaan kuvauskielelle, ne eivät - * joukkoina vastaa vielä lainkaan toisiaan. Vaikka osa termeistä ovat jopa kuvaus kielisellä nimeltään 35 samoja, ne eivät välttämättä vastaa toisiaan tai parametrien käytössä on eroja. Rikkaamman kielen . kuvauskielisessä muunnoksessa on paljon sellaisia termejä, joita ei ole toisen kielen muunnoksessa.

Kuvauskielisen muunnoksen tekemiseen tarvitaan tietämyskanta, jota tässä edustaa PROLOG-kieli.

Kuvauskielinen ilmaisu tapahtuu hyvin formaalisti semanttisella tasolla. Siitä on riisuttu kieliopin 40 kirjoitustapaan liittyvä syntaksi ja jokaiselle rakenteelle on annettu selvä syntaksinen nimi. Syntaksin 4 111107 suhde kuvauskieleen muotoon tallennetaan aputiedostoihin, mikä selitetään yksityiskohtaisesti jäljempänä. Kukin kuvauskielinen muunnos sisältää pelkistetyn informaation lähdekielen kieliopista. Tässä tiedostolla tarkoitetaan yleisesti joko erillisiä tiedostoja massamuistivälineessä tai tietokantaan tallennettua tietuejoukkoa. Käytännön sovelluksissa kaikki oleellinen tieto tallennetaan yhteen tietokan-5 taan, koska useimmissa kehitysympäristöissä tiedon käsittely on tällöin helpointa.

Tässä vaiheessa kuvauskielisistä muunnoksista ja formaalisti tallennetuista kieliopeista voidaan muodostaa täysin automaattisesti aputiedostot 31 ja 32 translaattoria varten (vaiheet 3 ja 3'). Muunnos algoritmit esitellään jäljempänä. Kuvan 1 aputiedostoina VX(a-e), 31 ja vastaavasti VY(a-e), 3T on esi-10 telty sanasto ja skannerin termit, tietotyypit, jäsennyslogiikka, generointikoodi ja muotoilulausekkeet.

Kun jaolliset termit puretaan komponenteiksi alimmalle tasolle asti, niin jäljelle jäävät varatut sanat, jotka muodostavat sanaston skanneria varten. Tietotyypit käsittävät kuvauskielisten esiintymien sidonnan alkuperäisiin termeihin ja niiden hierarkiatasoihin.

15 Jäsennyslogiikka esittää kaavat kunkin esiintymän purkamiseksi alkuperäisestä koodista kuvauskieliseen muotoon. Tässä on yleensä useita hierarkiatasoja siten, että päätermit ja alatermit sekä parametrit puretaan kukin omilla koodeillaan. On oleellista, että jaoteltavat termit muodostavat sisäisiä silmukoita, jotka täytyy purkaa niin alas kunnes jaoteltavia termejä ei enää löydy. Tässä voidaan käyttää jotain 2 o tunnettua hyvälaatuista jäsennyslogiikkaa, esimerkkinä LL(k)-jäsennin, joka on top-down tyyppinen algoritmi.

Generointikoodit esittävät oleellisesti vastakkaista prosessia jäsennyslogiikalle ja muotoilulauseet oleellisesti vastakkaista skanneritoiminnalle. Jos valittuun lähtökoodiin kohdistetaan saman lähdekielen 2 5 skanneri-, jäsennys- ja generointi- ja ja muotoilulausekket tuloksena pitäisi olla alkuperäinen koodi. Tätä voidaan käyttää translaaattoriohjelmiston tarkistukseeen.

Kuvaan 1 viitaten aputiedostojen ajon jälkeen suoritetaan tulo- ja lähtökielen kuvauskielisten termien interaktiivinen kytkentä, vaihe 4. Edullisesti tämä tapahtuu käyttäen graafista käyttöliittymää 5 ja 3 o päättelykonetta joka käyttää hyväksi yhtä tai useampaa seuraavaa yksinkertaista kriteeriä: ehdotetaan aikaisemmin kytkettyjä esiintymiä keskenään yhteen, ehdotetaan kuvauskielen termien perusteella samannimisiä esiintymiä/parametrejä yhteen, ‘ - ehdotetaan järjestyksen perusteella parametrejä keskenään yhteen.

35

Graafinen käyttöliittymä sisältää translaattorikehitystä tukevia piirteitä: rakenne-editori, joka tuntee tulo- ja lähtökielten rakenteet ja mahdollistaa konversio-ohjeen tarkentamisen yhä tarkemmalle tasolle napauttamalla vastaavaa termiä tulkki (päättelykoneen osajoukko), joka tarkistaa konversio-ohjeen loogisuuden: 40 - jokaisella parametrilla tulee olla vähintään kaksi käyttöä, sijoitus ja arvon hyödyntäminen 5 111107 jokaisella käytetyllä konversio-ohjeella, johon on viitattu on oltava määrittelykoodi kun konversio-ohjeen parametreille annetaan niiden tyyppejä vastaavat nimet, voidaan suorittaa tyyppitarkistukset jokaiselle konversio-ohjeen toiminnolle jo ennen translaattorin * kehittämistä 5 - tulkilla voidaan konversio-ohjeet testata itsenäisinä kokonaisuuksina ennen translaattorin * kehittämistä Tällä tavoin suoritetaan muunnetun tulokielen termin VXf liitäntä valittuun lähtökielen muunnettuun termiin VYn käsittäen portaittain: 10 - päätermien kytkennän tosiinsa - esiintymien sovituksen toisiinsa.

Tämän jälkeen tallennetaan kunkin muunnetun tulokielen termin (VXj) konversio-ohje (VX«-VY) tiedostoon 41 translaattoria varten.

15 Konversio-ohjeen valmistumisen yhteydessä haetaan se osa lähtökielen generointikoodia linkitettynä kunkin päätermin konversiohjeeseen, joka on tarpeen kulloisenkin kovertoidun päätelmin purkamiseksi osiin, ja tallennetaan se tiedostoon 42.

Nyt on valmiina täydellinen informaatio mielivaltaisen tulokielisen X koodin (tietokoneohjelman lähdekoo- 2 0 din) kääntämiseksi lähtökielelle Y. Vastaava translaattoriohjelma tehdään vaiheessa 6, jolloin käänne tään translaattorin sovelluskoodi ja linkataan edellä aikaansaadut tiedostot samoinkuin käyttöjärjestelmän vaatimat aputiedostot siihen. Edullisesti käytetään PROLOG-kieltä, jonka syntaksi on lyhyttä ja deklaratiivistä ja siten soveltuu erinomaisesti lopulliseksi translaattorin koodiksi ja välikieleksi sekä testausaineistoksi.

25

Konversio-ohje ja aputiedostot voidaan sijoittaa suoritettavaan ajotiedostoon halutulle alustalle, kuten esim. MS-DOS, MS-Windows tai Linux. Toiminnallisesti kyse on kuitenkin eri tietojoukoista oli ne erillisenä tiedostoina, yhteisessä tietokannassa tai suoritettavan ohjelman sisällä.

3 0 Käännöksen toteuttaa (kuva 2) järjestelmä, yleensä PC-laitteisto, jossa on translaattori (X>Y), yleensä ohjelma kytkettynä syöttötiedostoon 7, joka translaattori lukee skannerin S avulla syöttötiedostoa ja generoi tietokoneohjelmasta kovertoidun version, ja jossa translaattoriin kuuluu konversio-ohjeet VX»VY, 41 liittyen kuhunkin « tulokieliseen termiin, 35 - käännetty tiedosto 12 kytkettynä translaattoriin (X>Y) täten generoidun tietokoneohjel- . man käännetyn version vastaanottamiseksi, toimenpide kirjasto, jossa on translaattorista (X>Y) kutsuttavia rutiineja.

Järjestelmään kuuluu myös: ensimmäinen aputiedosto VX(c), 31c sisältäen tulokielen jäsennyslogiikan valitulle 40 semanttiselle kuvauskielelle (V), 6 111107 toinen aputiedosto P(Y(d,e), sisältäen lähtökielen generointi- ja muotoilulausekkeet, jolloin translaattori (X>Y) on sovitettu: konvertoimaan tietokoneohjelman koodirivit ensin kuvauskieliseen muotoon, vaihe 9, käyttäen ensimmäisen aputiedoston VX(c) jäsennyslogiikkaa; 5 - sitten konvertoimaan ne, vaihe 11, kuvauskielisessä muodossa käyttäen sanottua konversio-ohjetta VX»VY,41 ja generoimaan ja muotoilemaan, vaihe 11, kuvauskielinen lähtökielinen koodi formaaliksi lähtökielen koodiksi 12 käyttäen lähtökielen generointikoodia VX(d), 42 ja muotoilulau-sekkeita Y(d), 42.

10

Lisäksi molempien kielien tietotyypit VX(b) ja VY(b) tulee olla käytettävissä eri vaiheissa. Nämäkin on tallennettu translaattoria varten ellei ne sisälly jo muihin tietoihin.

Kuvissa 3 ja 4 esitellään interaktiivisen kytkennän graafista käyttöliittymää. Kuvassa 3 käyttöliittymän 15 ensimmäisellä sivulla on valintaikkunat 20 ja 21 ehdotettaville termeille, valintaikkunat 23 ja 24 niiden esiintymille, valintaikkuna 22 get-lauseen nimelle, valintaikkuna 25 muodostuvalle konversio-ohjeelle. Useimmissa valintaikkunoissa termeistä on klikattavissa valintalista ponnahdusikkunaan (ei näytetty). Kussakin tällaisessa valintaikkunassa kukin komponentti toimii linkkinä vastaavaan esille tulevaan valintalistaan.

20

Kuvassa 4 toiminnallisesti samanlaisista valintaikkunoista käytetään samoja viitenumeroja kuin edellä. Lisäksi tässä on valintaikkunat 23’ ja 24' esiintymien lähdekielisille muodoille sekä valintaikkunat 26 ja 27 termin esiintymille.

25 TERMIEN KYTKEMINEN, PROSEDUURI, kuva 3

Valitaan X-termi ja Y-termi, tässä PROGRAM ja STATEMENT r - Painetaan Yhdistä-painiketta, jos kytkentä tapahtuu päätermien tasolla (joko täysin samat termit tai kytkentä on tehty jo alemmalla tasolla).

Painetaan Arvaus-painiketta, jos päätermit ovat lähellä toisiaan Tällöin kehitin "arvaa" 3 0 kaikki kytkentävaihtoehdot.

Yksilöllinen kytkentä tehdään esiintymä kerrallaan, tässä COMMANDLIST ja cs(COM-POUNDSTMNT1). Se tehdään Määrittely-painikkeen kautta käyttäen dialogia ‘Termien sovitus” (Kuva 4).

* - - Syntynyttä koodia voidaan muokata jälkikäteen käsinmuokkaus-ruudussa.

35 TERMIEN SOVITTAMINEN, PROSEDUURI, kuva 4:

- Valitaan päätermit, alla EXPRESSION ja GENEXPRESSION

-Valitaan aluksi yhteenlaskua vastaava esiintymä "add" tulokielestä. Kehitin voi ehdottaa sen vastineeksi esiintymää "math_oper" lähtökielestä, koska molempien syntaksissa esiintyy termi 7 111107 - Napautetaan "koodin runko"-painiketta, jolloin konversio-ohjeen otsikkokenttä ilmestyy näyttöön parametreineen. Ensimmäinen parametri on tulokielen tietorakenne ja toinen parametri lähtökielen tietorakenne. Tarkoituksena on saada ne vastaamaan toisiaan eli muodostaa semanttinen kytkentä niiden välille. Yhteensopivuus saadaan kun napautetaan Y-kielen parametreja niin monta kertaa, että 5 päästään tilanteeseen, jossa X- ja Y-kielten parametrien lukumäärä on sama. Tarvittaessa käytetään vakiotietoja uudessa kielessä tai merkitään tulokielen ylimääräiset parametrit tarpeettomiksi (alaviivalla). Tässä tapauksessa lähtökielen matemaattinen yhteenlaskuoperaattori tulee valita käsin. Valinta tapahtuu napauttamalla sanaa MATH_OPER kerran, jolloin kehitin esittelee sen alavaihtoehdot, jotka tässä tapauksessa ovat plus, minus, star ja div.

10 - Nyt havaitaan, että tulo- ja lähtöparametreissa on sama muuttujamäärä. Tuloparametrissa on muuttujat EXPRESSIONI ja EXPRESSION2 ja lähtöparametrissa muuttujat GENEXPRESSION1 ja GENEXPRESSION2. Havaitaan edelleen, että nyt ollaan kytkemässä yhteen termejä EXPRESSION ja GENEXPRESSION ja tätä kytkentää voidaan siten rekursiivisesti käyttää hyväksi sovittamaan termin sisäiset tulo- ja lähtöparametrit.

15 - Lopuksi napautetaan painiketta "kehitä koodi", jolloin kehitin luo tarvittavan Prolog-kielisen konversio-ohjeen muodostamalla alemman tason konversiokutsut tulo- ja lähtötermien välisille konversioille. Generointi on nyt valmis.

Kuvassa 5 näkyy kielen X, tässä tapauksessa Minilan, rakenne.

20 Vasemmanpuolimmaisin käsite on PROGRAM, joka on kielen alkusymboli, 13. Se jakaantuu osa-komponentteihin lista-määrittelyn kautta. Lista koostuu COMMAND-nimisistä käsitteistä, 14, jotka ovat tässä semanttisilta nimiltään muotoa assignment, 16 eli sijoitus ja loop, 15 eli ohjelmasilmukka. Ohjelmasilmukan sisällä voi olla PROGRAM-käsite, 17 uudestaan, mikä tarkoittaa alistettua ohjelma-pätkää. Useimmissa lähdekielissä nämä olisi eroteltava toisistaan eli alkusymboli voi olla nimeltään 25 PROGRAM ja ohjelmalohkot nimeltään BLOCK. Minilan-kielen hierarkiapuussa on enimmällään kuusi tasoa. Esim. Pascal-kielen vastaava puu haarautuu enimmillään 20 tasoon ja C-kielen rakenne-puu noin 30 tasoon kielen rakenteen sisäkkäisyydestä johtuen. Julkaisussa Turbo C Reference Guide, 1987, ISBN-0-87524-160-3 C:n kielioppi on esitetty syntaksiltaan termi termiltä.

3 0 Kaaviossa tyypillisesti alaspäin (eli oikealle) mennessä joka toinen termi on kirjoitettu isoilla kirjaimilla ja joka toinen alkaa pienellä kirjaimella. Isot kirjaimet merkitsevät kieliopin käsitettä produktio (tumma pohja) eli päätermi ja pienellä alkavat termin esiintymiä, jotka alkavat semanttisella nimellä. Solut, jotka alkavatovat linkkejä uuteen kieleen, tässä tapauksessa C:hen (vaaleanharmaa pohja). Linkin alussa kerrotaan uuden kielen produktion nimi ja kautta-merkin perässä semanttinen käsite, 35 jota X-kielen termi uudessa kielessä vastaa. Semanttinen käsite (vaaleanharmaa pohja) muodostuu automaattisesti translaattorikehittimessä käyttöliittymätoimien avulla.

Kuten asiantuntijalle on selvää, menetelmällä on lukuisia sovelluskohteita ohjelmistotekniikan eri alueilla. Seuraavassa esitellään sovelluskohteita, joissa kaikissa käytetään vähintään yhtä tulokieliop- 40 pia ja vähintään yhtä lähtökielioppia sekä niiden välistä risteytystä menetelmän mukaisesti: 8 111107 1. Kehitetään translaattori kielestä toiseen, esimerkiksi käännetään Pascal-kielinen lähdekoodi C-kie-iiseksi koodiksi. Kielet risteytetään menetelmän mukaisesti.

2. Kehitetään protokollaohjelmistoja sulautettuihin järjestelmiin. Kehitetään soveltava kielioppi (domain specific language DSL), joka pohjautuu esimerkiksi C-kieleen mutta sisältää lisäyksinä kutsut 5 kohdealueen kirjastorutiineihin ja keskeisiin tietotyyppeihin. Protokollakielioppi risteytetään siten tämän uuden soveltavan kielioppin kanssa. Protokollakielenä voi olla esimerkiksi CSN.1 -niminen protokollakieli, jota käytetään GPRS- ja UMS-järjestelmissä. Menetelmällä saadaan automaattisesti rakennettua valmiit protokollasovelluksten koodekit ja dekoodekit kyseisille tiedonsiirtorajapinnoille.

3. Luodaan konfigurointisovelluksia teollisuustuotteisiin tai ohjelmistosovelluksiin siten, että tulokiele-io nä on sovelluskohtainen määrityskieli (DSL) ja lähtökielenä valittu ohjelmointikieli. Sovelluskielen termejä ovat mm. tuoteominaisuudet, tietohakemistot tai tiedostojärjestelmät ja ne määritellään kielioppina. Asiakasvaatimukset syötetään käyttöliittymän avulla, minkä tuloksena syntyy tulokielistä tekstiä. Se muunnetaan risteytysmekanismin avulla esimerkiksi C-kieliseksi tuotekonfigurointiohjel-m istoksi.

15 4. Ohjelmistoja käännetään rajoitetun sanavaraston kielelle. Tulokielenä on ohjelmointikieli ja lähtö-kielenä haluttu luonnollisen kielen osajoukko kiinteine lausejärjestyksineen.

5. Siirretään ohjelmakoodia CASE-välineisiin ohjelmistokehityskäyttöön. Ohjelmistot voidaan määritellä korkean tason kielellä (domain specific language) projektin alkuvaiheessa. Määrittelyn tarkentuessa siirrytään perinteisiin CASE-työvälineisiin kun huomioidaan CASE-välineen rajapinnat ja tie- 20 toesitysmuodot, esimerkiksi tunnettu UML-esitysmuoto.

6. Poimitaan ohjelmakoodista tietorakenne- ja oliorakennetiedot ja ne muunnetaan CASE-välineen piirrosmerkeiksi ja sisäisiksi tietorakenteiksi. CASE-välineen osuus muodostaa lähtökielen ja ohjelmointikieli tulokielen.

7. Kehitetään testidataa automaattisesti sovellusohjelmistoon käyttäen erillistä testauskieltä joka 25 risteytetään sovelluskielen kanssa. Testauskieli voi toimia esimerkiksi asiakassimulaattorina, joka antaa Internet-käyttöliittymän mukaisia komentoja ja lähtötietoja.

» · (

Seuraavissa kuvissa esitellään esimerkkiohjelman kääntäminen debuggerin avulla.

3 0 Lähdekielinen (Minilan) esimerkkiohjelma: 1 = 0. repeat 1=1+1.

Until l<11.

35

Vastaava tokenjist: [t(name("i"),1),t(eq,3),t(number(0),5), t(dot,6),t(repeat,10),t(name("i"),17),t(eq,19),t(name('T'),21),t(plus,22),t(number(1),23),t(dot,24),t(until, 28),t(name("i"),34),t(lt,35),t(number(11 ),36),t(dot,38)] 40 X-kielinen jäsennyspuu (kuvauskielellä): 9 111107 [assignment(var("i")lnumber(0)),loop([assignment(var(,,i")iadd(value(var("i")),number(1)))],var("i"),num ber(11))] Tässä kuvauskieliseen termiin “loop” sisältyy erityinen ehtolause “VAR < EXPRESSION”.

5 Kuvassa 6a esitetään translaation ensimmäinen vaihe. Tasolla 3 on koko ohjelma, joka käynnistää muunnoksen get_program_statement, mennään siis C:n Statement-lausekkeeseen, C:n lauseke jaetaan edelleen listaan, joka vastaa minilan-kielen Program-rakennetta. Taso 2 on siis välivaihe. Tasolla 1 koko ohjelma on parametrina. Alaviiva tarkoittaa muuttujaa, jonka arvo ei ole vielä määritelty. Tasot 4-6 liittyvät käyttöliittymään (eivät ole olennaisia).

10

Kuvassa 6b esitetään seuraava vaihe, jossa sijoituslause poimitaan listan alusta pois muuttujaan H1. Edelleen ollaan Statementlist-tapauksessa. Muuttuja T1 on tuloparametri, ks. s. 18: get_PROGRAM_STATEMENTLIST(ö,[]):-!.

get_PROGRAM_STATEMENTLIST([H1 IT1 ],[H2IT2]):- 15 get_COMMAND_STATEMENT(H1, H2), get_PROGRAM_STATEMENTLIST(T1 ,T2),!.

Seuraavassa kuviin liittyen get- ja gen-lauseiden antamia tuloksia esitellään yksityiskohtaisesti. Kuvassa 6b: SIJOITUSLAUSEKE: assignment(var("i''),number(0)) 2 0 TULOS:expr(asse(generate(relative_oper( GENEXPRESSIONl„eq(),GENEXPRESSION3))))) ADD-EXPRESSION: get_EXPRESSION_GENEXPRESSION( add(value(var("i")),number(1)) 25 TULOS: math_oper(var(var(Y,0)),plusconst(i(1))))

Kuva 6d, rivi 1, etsitään vastaavuus sijoituslauseelle “i=i+1" SIJOITUSLAUSEKE: assignment(var("i“),add( value(var("i")),number(1))) 30 TULOS: expr(asse(generate(relative_oper( GENEXPRESSION1„eq(),GENEXPRESSION3)))))

Kuva 6e, rivi 1: LOOP-LAUSEKE: loop([assignment(var("i''), ‘ add(value(var("i")),number(1)))],var("i''),number(11)) 3 5 TULOS:is(do(STATEMENT 1 „generate(relative_oper( GENEXPRESSION1 „lt()„GENEXPRESSION3)))))

Kuvassa 6g rivillä 1 on X-kielen silmukan viimeinen komento.

40 Y-kielinen vastine kokonaisuudessan, kuva 7a r1: 10 111107 “cs(stmntlist([expr(asse(generate(relative_oper(var(var("i",0)),eq,const(i(0)))))),is(do(cs(stmntlist([expr (asseigenerateirelative^perivarlvarCT1,0)), eq>math_oper(var(var(,,i", 0)), plus, const(i(1)))))))])), generat e(relative_oper(var(var("i",0)),lt,const(i(11))))))]))” 5 Y-kielen YHDISTETTY LAUSEKE, Fig 7e: “cs(stmntlist([expr(asse(generate(relative_oper(var(var{"i,,,0)),eq,const(i(0)))))),is(do(cs(stmntlist([expr (asse(generate(relative_oper(var(var("i", 0)), eq,math_oper(var(var("i" ,0)), plus, const(i(1)))))))])), generat e(relative_oper(var(var("i",0)),lt,const(i(11))))))]))” 10 Y-kielen EXPRESSION LAUSEKE, muodostetaan “i=0", Fig.7b r.1: expr(asse(generate(relative_oper(var(var(,'i",0)),eq,const(i(0)))))) GENEXPRESSION-LAUSEKE: relative_oper(var(var("i“,0)),eq,const(i(0))) relative_oper- LAUSEKKEEN TULOKSET: i,=,0, Fig. 7c r.1 15 GENEXPRESSION-LAUSEKKEEN MUOTOILTU TULOS: i = 0 EXPRESSION LAUSEKEEN TULOS: i = 0 MUOTOILTU EXPRESSION LAUSEKE : i = 0 ; 2 0 Kuvassa Fig. 7d r.1: Tässä muotoillaan “i=i+1" Y-kielen ITEROINTILAUSEKE, Fig 7e r.4: “is(do(cs(stmntlist([expr(asse(generate(relative_oper(var(var("i",0)),eq,math_oper(var(var("l",0)),plus, const(i(1)))))))])), generate(relative„oper(var(var("i", 0)), It, const(i(11))))))” 2 5 Y-kielen YHDISTETTY LAUSEKE, Fig 7e r.2: “cs(stmntlist([expr(asse(generate(relative_oper(var(var("i",0)),eq,math_oper(var(var("i",0)), ·;· plus,const(i(1)))))))]))” Y-kielen EXPRESSION LAUSEKE, : “expr(asse(generate(relative_oper(var(var("i",0)),eq,math_oper(var(var("i",0)),plus,const(i(1 30 )))))))” GENEXPRESSION-LAUSEKE: relative_oper(var(var(''i",0)),eq,math_oper(var(var("i",0)),plus,const(i(1)))) * t GENEXPRESSION-LAUSEKE: 35 math_oper(var(var("i",0)),plus,const(i(1))) math_oper- LAUSEKKEEN TULOKSET: i,+,1 GENEXPRESSION-LAUSEKKEEN MUOTOILTU TULOS: i + 1 40 relative_oper- LAUSEKKEEN TULOKSET: i,=,i + 1 11 111107 GENEXPRESSION-LAUSEKKEEN MUOTOILTU TULOS: i = i +1 EXPRESSION LAUSEKEEN TULOS: i = i + 1 MUOTOILTU EXPRESSION LAUSEKE: i = i +1 ; 5 YHDISTETYN LAUSEKKEEN TULOS: {i = i + 1 ;Fig 7e r.1: MUOTOILTU YHDISTETTY LAUSEKE (gen_outputin jälkeen): {i = i +1 ;} GENEXPRESSION-LAUSEKE: relative_oper(var(var("i",0)),lt,const(i(11))) 10 relative_oper- LAUSEKKEEN TULOKSET: i,<,11 GENEXPRESSION-LAUSEKKEEN MUOTOILTU TULOS: i < 11

Kuvissa 7e ja 7f muotoillaan while-do-silmukka.

ITEROINTILAUSEKKEN TULOS: )do {i = i +1 ;} while (i < 11 ) 15 MUOTOILTU ITEROINTILAUSEKE do {i = i + 1;} while (i < 11 ); YHDISTETYN LAUSEKKEEN TULOS: {i = 0; do {i = i +1 ;} while (i < 11 );} MUOTOILTU YHDISTETTY LAUSEKE (gen_outputin jälkeen): 20 {i = 0 ; do {i = i + 1 ;} while (i < 11 );} LOPPUTULOS: {i = 0; do {i = i + 1 ;} while (i < 11 );} (Fig.7h r.1)

MATRIISIPERIAATE

25

Jokainen formaali kieli voidaan kuvata vektorina X, X = {Xr.X) ja kukin termi voidaan kuvata vektorin alkiona. Tässä alleviivaus kuvaa vektorimuotoa. Siten kahden kielen välinen suhde ja mahdolliset konversiot termeittäin voidaan kuvata vektorien X (tulokieli) ja ? (lähtökieli) välisenä suhteena, joka on käytännössä matriisi. Järkevä tulos saadaan translaatiosta tulo- ja lähtökielen välillä vain kun 30 jokaiselle tulokielen termille löytyy vähintään yksi semanttinen ratkaisu eli vastaavuus lähtökielestä, jolloin ratkaisua vastaava termi voidaan ottaa käyttöön translaattorissa ja tulostaa myöhemmin sitä vastaava lähdekielinen osuus.

U % I

' Keksintö kuvataan kahden kielen väliseksi konversioksi matriisikaavalla 35 V — [A] * X, jossa [A] on matriisi, jossa kerrotaan vektorin X ja vektorin Ϋ välinen suhde. Käytännös-. sä suhde muodostuu konversio-ohjeista. Yhdessä matriisin solussa A,, on siis kielen X alkion i ja kielen Y alkion j välinen konversio-ohje, jos konversio on mahdollinen.

Valinta matriisista tulokielen mukaan tapahtuu numeroitujen termien semanttisen nimen (XJ perus-40 teella, jolloin määräytyy indeksi i ja valinta lähtökielen perusteella tapahtuu käyttöyhteyden mukaan, 12 111107 jolloin määräytyy indeksi j. Käyttöyhteys perustuu vastaavan esiintymän muotoon, joka määräytyy vastaavaa ylempää konversio-ohjetta luotaessa.

Esimerkiksi kun luodaan kielen X sijoituslauseen assignment(VAR, EXPRESSION) vastinetta uudes-5 sa kielessä Y, jossa on vastaava termi bind(VAR, EXPRESSION) on luontevaa, että tehdään kytkentä EXPRESSION-päätermistä lähtökielen EXPRESSION-päätermiin kaikkien niiden mahdollisten esiintymien välille. Edullisinta on käyttää pienin mahdollinen määrä linkkejä kielten välillä ja valita luontevin tapa liittää termejä toisiinsa. Jos linkki kielestä kieleen on määritelty kieliopin jollakin tasolla, niin kaikissa muissa linkeissä tulokielen termistä uuteen kieleen voidaan viitata edellämainittuun linkkiin 10 suoraan, jos uusi linkki on korkeammalla hierarkiatasolla.

Esimerkki:

Oletetaan, että tulokielen EXPRESSION sisältää kolme termiä ja siitä tarvitaan linkit päätermeihin EXPRESSION, jossa on viisi termiä ja ASSIGNMENT_EXPRESSION, jossa on kolme termiä. Jos 15 molemmat tapaukset käsiteltäisiin kattavasti konversio-ohjeissa tarvitaan vähintään kuusi linkkiä (3 molempiin). Jos ASSIGNMENT_EXPRESSION on EXPRESSION-termin osajoukko ja linkki EXPRESSION->ASSIGNMENT_EXPRESSION on jo määritelty, voidaan linkissä EXPRESSION-EXPRESSION viitata konversio-ohjeeseen get_EXPRESSION_ASSIGNMENT_EXPRESSION. Näin tarvitaan vain kolme linkkiä suoraan termeihin ja lisäksi siirtyminen päätermistä EXPRESSION 20 päätermiin EXPRESSION.

Toisaalta kun luodaan linkki esimerkiksi päätermistä EXPRESSION päätermiin MATHEMATI-CAL_EXPRESSION tarvitsee määritellä vain tulokielen matemaattiset lausekkeet uuteen termiin nähden.

25

Edellämainitulla periaatteella toteutetaan myös monikielisiä translaattoreita, joissa yhtenä matriisina f on ohjelmointikieli, matriisi [A] ja toisena matriisina [B] esimerkiksi tiedonsiirtoprotokolla tai käyttöjär- jestelmärajapinta tai kirjasto.

Näin tuotetaan Y-kielen mukaista lähdekoodia, joka on kahden matriisin tulos: 30 Ϋ = [A]* [B] * X.

Jos uudessa rajapintamatriisissa [B] solulla on valittu arvo, esimerkiksi tyhjä, se tarkoittaa sitä, että [A]-matriisin tulosta käytetään sellaisenaan uudessa lähdekoodissa. Jos solun arvo on jokin muu, esimerkiksi tyyppimuunnoskomento tai tekstin muotoilulauseke, silloin vastaavaa uutta muunnosta käytetään hyväksi.

35 TRANSLAATION JAKAMINEN USEISIIN VAIHEISIIN:

Translaatio voidaan jakaa äärelliseen määrään erillisiä vaiheita, jotka kaikki hyödyntävät alkuperäistä jäsennyspuuta lähtötietonaan, mutta jotka lisäksi saavat edellisistä vaiheista täydentäviä tietoja. Esimerkiksi edellisen vaiheen symbolitaulun tietoja käytetään seuraavassa vaiheessa, jolloin määrite-40 tään sovelluksen olioluokat ja kolmannessa vaiheessa tulostetaan lopullinen koodi.

13 111107 Ϋ = [A] * [Β] * [C] * X .

SYMBOLITAULUJEN LUOMINEN: ' Menetelmällä luodaan symbolitauluja X-kielen jäsennyspuuta lähtöaineistona käyttäen seuraavasti.

5 Halutut kielen termit määritellään kielen symbolimuuttujiksi dialogissa tai suoraan kielioppitiedostos-sa. Symboli luodaan käyttäen symbolitauluun varattua päätermin nimeä, esimerkiksi VAR tarkoittaa muuttujan nimeä ja STRUCT tietueen eli struktuurin nimeä. Kieliopista määrittely tehtäisiin seuraavasti: SYMBOLTABLE = VAR -> variable(VAR), STRUCT -> struct(STRUCT).

10 Näin ohjelma käydessään läpi jäsennyspuun konversion ensimmäisissä vaiheissa tallentaa kaikki muuttujaviittaukset välimuistiin aina kun se viittaa VAR- tai STRUCT-tyyppisiin termeihin. Siirryttäessä uuden kielen generointiin tulostetaan tarvittavat muuttujamäärittelyt (VAR ja STRUCT) kyseiseen kohtaan kyseisen metodin tai funktion alkuun tai esimerkiksi koko ohjelmatiedoston alkuun.

15 Seuraavassa esimerkkiin liittyvät kielioppikuvaukset ja tiedostot sekä PDL-algoritmejä tiedostojen luomiseksi automaattisesti. PDL-kuvauksissa sanaa päätermi vastaa sana Production, sanaa termi vastaa sana Term ja sanaa esiintymä sana Subterm sekä jakamatonta termiä sana Terminal.

1) Tulokielen X kielioppi formaalina esityksenä 2) Kuvauskielinen (Prolog) muunnos 20 Kielioppi esitetään muodossa Terminnimi Esiintymät Esiintymä = Syntaksimuoto Semanttinen_vastaavuus PROGRAM = COMMAND* separator dot COMMAND = 25 VAR eq EXPRESSION -> assignment(VAR,EXPRESSION), repeat PROGRAM until VAR It EXPRESSION -> loop(PROGRAM,VAR,EXPRESSION) » · < » EXPRESSION = EXPRESSION plus EXPRESSION -> add(EXPRESSION, EXPRESSION) 30 VAR -> value(VAR), number(INTEGER) -> number(INTEGER) * Λ ' ' VAR = name(STRING) -> var(STRING) 35 m 3) X-kielen sanasto (varatut sanat)

Esimerkissä varatut sanat kootaan kieliopista mm.: repeat, until, plus, It, dot. Muut paitsi repeat ja until ovat sisäisiä lyhennyksiä. Sanat tallennetaan tied ostoon muodossa strjok("repeat",repeat), jossa 40 oikeanpuolinen repeat tarkoittaa semanttista osaa ja vasemmanpuolinen ’’repeat1' syntaksiosaa.

14 111107

Seuraavassa PDL (programming design language) algoritmi.

*1 FOR EACH WORD IN GRAMMAR DEFINITION

*2 IF WORD IS A RESERVED WORD (X)

5 *3 STORE IT INTO GLOSSARY FILE

*4 AND MAKE A STRING str_tok(MX’\X).

str_tok(".",dot) str_tok("=",eq) 10 str_tok("repeat",repeat) str_tok("until",until) str_tok("<",lt) str_tok("+",plus) 4) X-kielen tietotyypit 15 Datatyypit kootaan kunkin termin oikealta puolelta: assignment, loop, add, var, number, value. Seuraavassa PDL (programming design language) -algoritmi datatyyppien keräämiseksi.

*FOR EACH TERM AND SUBTERM

* GET THE RIGHT HAND SIDE (RHS) OF EACH GRAMMAR CLAUSE

* STORE THE RHS INTO GRAMMARS SEMANTICS AND INTO DATABASE

20 PROGRAM = COMMAND* COMMAND = assignment(VAR,EXPRESSION); loop(PROGRAM,VAR,EXPRESSION) U EXPRESSION = add(EXPRESSION, EXPRESSION); 25 value(VAR); number(INTEGER) VAR = var(STRING) ... 30 5) Scannerin termit (koko sanasto) ♦

Termi p_tok on kaikkien mahdollisten kielisymbolien kokoelma. Lähdekoodissa se on informaatiota skanneria varten. Skanneri lukee syöttötiedostoa ja luokittelee jokaisen sanan tiedostossa.

Seuraavassa vastaava PDL -algoritmi.

35 *1 FOR EACH TERMINAL IN GRAMMAR DEFINITION

*2 STORE THE TERMINAL INTO P_TOK-DOMAIN

P_TOK = dot(); 15 111107 eq(); repeat(); until();

It(); 5 plus(); number(INTEGER); name(STRING); nill 10 61 X-kielen iasennvsloaiikka.

Jäsennyskoodi (prolog-kielellä) kehitetään automaattisesti käyttäen top-down.tekniikkaa. Seuraavassa vastaava PDL - algoritmi.

*1 USE RECURSIVE DESCENT - METHOD (DIFFERENCE LIST):

15 *2 FOR EACH PRODUCTION

*3 GENERATE A CODE FOR EACH PRODUCTION

*4 OF FORMAT "s_+ PRODUCTION NAME" WITH LL1 AND LLO AS PARAMETERS *5 AND FOUND PRODUCTION TERMS AS AN OUTPUT PARAMETER.

*6 CALL PRODUCTION'S SUBTERMS IN PROPER ORDER

20 *7 RENUMBER LIST TERMS LLn STARTING FROM 1 WITH LLO as OUTPUT LIST

*8 FIND TOKENS OF SYNTAX BY A SUITABLE CALL (pexpect)

*9 COLLECT ALL INFORMATION INTO PARSE TREE WITH STARTSYMBOL AS A ROOT * 10 GENERATE SUB-PREDICATES FOR EACH SEPARATE PARAMETER COMBINATION

• · < *11 OF CURRENT PRODUCTION.

25

Ylin taso: program- ia command-termit s_program(LL1,LLO,[COMMANDIPROGRAM]):-s_command(LL1 ,LL2, COMMAND),!, v* - 30 s_program1(LL2,LLO,PROGRAM).

s_program(LL,LL,0).

s_program1 ([t(dot,_)ILL1],LL2,PROGRAM):-!, s_program(LL1 ,LL2,PROGRAM). s_program1(LL,LL,Q).

3 5 s_command(LL1 ,LLO,assignment(VAR,EXPRESSION)):-s_var(LL1 ,LL2,VAR), 16 111107 pexpect(t(eq,J,LL2,LL3), s_expression(LL3,LL0, EXPRESSION),!. s_command([t(repeat,„)ILL1 ],LLO,loop(PROGRAM,VAR,EXPRESSION)):-!, s_program(LL1 ,LL2,PROGRAM), 5 pexpect(t(until,J,LL2,LL3), s_var(LL3,LL4,VAR), pexpect (t( It,_), LL4, LL5), s_expression (LL5, LLO, EX P R ESS ION). s_command(LL,_,_):-psyntax_error(command,LL),fail.

10 7) X-kielen iäsennvsloaiikka,

Alempi taso, EXPRESSION- ia VAR-termit s_expression(LL1,LLO,EXPRESSION):-15 s_expression1 (LL1,LLO,EXPRESSION).

s_expression1 (LL1,LLO,EXPRESSION _):- s_expression2(LL1,LL2,EXPRESSION), s_expression3(LL2, LLO, EXPRESSION, EXPRESSION.). s_expression2(LL1,LL0,value(VAR)):-20 s_var(LL1,LLO,VAR),!.

s_expression2([t(number(INTEGER),_)ILL],LL,number(INTEGER)):-l.

s_expression2(LL,_,_):-psyntax_error(expression2,LL),fail.

s_var([t(name(STRING),_)ILL],LL,var(STRING)):-!.

s_var(LL,_,_):-psyntax_error(var,LL),fail.

25 s_expression3([t(plus,JILL1],LLO,EXPRESSION,EXPRESSION.):-!, s_expression2(LL1 ,LL2,EXPRESSIONI), :* s_expression3(LL2,LLO,add(EXPRESSION,EXPRESSIONI),EXPRESSION.).

s_expression3(LL,LL,EXPRESSION,EXPRESSION).

30 8) X-kielen aenerointikoodi ,., Generointi on jäsennykselle vastakkainen operaatio. Generointikoodi (prolog-kielellä) rakennetaan « ‘ ' tietokannan päätermitietueista siten että kukin termi jaetaan sen esiintymiin ja lopullinen koodi stringi 3 5 (ulostuleva lähdekoodi) on alatermien summa, jotka on muotoillaan muotoilulausekkeiden avulla.

Seuraavassa vastaava PDL - algoritmi.

*1 FOR EACH PRODUCTION

*2 IF PRODUCTION IS LIST GENERATE A LIST GENERATING COMMAND

*3 ELSE GENERATE A TERM GENERATING COMMAND

17 111107 * *LIST GENERATING COMMAND:

* 1 GENERATE LIST END EVENT: EMPTY LIST-> EMPTY STRING

* 2 GENERATE LAST EVENT CASE: GENERATE A CALL FOR CURRENT LIST'S MEMBER 5*3 OTHERWISE: GENERATE A CALL FOR CURRENT LIST’S MEMBER + * 4 GENERATE A RECURSIVE LOOP FOR OTHER MEMBERS OF THE LIST Ohjelma, joka on peräkkäinen lista käskyistä, kootaan stringiin Str. gen_PROGRAM(0, gen_PROGRAM([H], Str):- gen_COMMAND(H, Str),!.

10 gen_PROGRAM([HIT], Str):- gen_COMMAND(H, St1), gen_PROGRAM(T, St2), format(Str,"%s. %", St1,St2).

TERM GENERATING COMMAND:

*1 FOR EACH PRODUCTION 15 *2 FOR EACH SUBTERM

*3 GENERATE A CLAUSE IN FORMAT *4 "gen_PRODUCTION(SUBTERM, Str):-" AS A HEAD AND

*5 NUMBERED CALLS OF EACH SUBTERM PARAMETERS AND

*6 AND PARAMETER OUTPUT STRINGS CALLED TOGETHER BY

20 *7 AND SLIST AND gen_output-CALLS.

* 8 WHERE Str IS GENERATED SOURCE CODE FOR CURRENT LANGUAGE

• · ( »

Sijoitus (assignment) -käsky sisältää muuttujan (sen ulostulomuoto on tässä Str1) ja lausekkeen (sen ulostulo muoto on tässä Str2) ja ne lisätään mutoiltuun stringiin nimeltään ttcommand_assignment" 25 käyttäen listaa Slist. Lauseke gen_output noutaa muotoilustringin autojorm-tietueesta samalla argumentilla.

. . gen_PROGRAM(ö,"").

* * gen_PROGRAM([H], Str):- gen_COMMAND(H, Str),!.

30 gen_PROGRAM([HIT], Str):- gen_COMMAND(H, St1), gen_PROGRAM(T, St2), format(Str,"% . St1,St2).

gen_COMMAND(assignment(VAR1 .EXPRESSION2) ,Str):-gen_VAR(VAR1,Str1), gen_EXPRESSION(EXPRESSION2,Str2), 35 SList =[Str1 ,Str2], 18 111107 gen_output(SList, "command_assignment", Str),!.

gen_COMMAND(loop(PROGRAM1 ,VAR2,EXPRESSIONS) ,Str):-gen_PROGRAM(PROGRAM1 ,Str1), 5 gen_VAR(VAR2,Str2), gen_EXPRESSION(EXPRESSION3,Str3), SList =[Str1 ,Str2,Str3], gen_output(SList, "commandjoop'1, Str),!.

10 gen_EXPRESSION(add(EXPRESSION1,EXPRESSION2) ,Str):-gen_EXPRESSION(EXPRESSION1 ,Str1), gen_EXPRESSION(EXPRESSION2,Str2), SList =[Str1,Str2], gen_output(SList, "expression_add'', Str),!.

15 gen_EXPR ESS I ON (value( VAR 1) ,Str):-gen_VAR(VAR1 ,Str1), SList =[Str1], gen_output(SList, "expression_value", Str),!.

20 gen_EXPRESSION(number(INTEGER1) ,Str):-strJnt(Str1 JNTEGER1), SList =[Str1], genjoutput(SList, "expression_number", Str),!.

25 gen_VAR(var(STRING1) ,Str):-:·' gen_STRING(STRING1,Str1), SList =[Str1], gen_output(SList, "var_var", Str),!.

30

Gen_output suorittaa lopullisen lauseen viimeistelyn muotoilulauseita käytäen.

9) X-kielen muotoilulauseet Seuraavassa vastaava PDL - algoritmi.

35

* 1 FOR EACH PRODUCTION AND SUBTERM NAME *2 GENERATE A FORMAT CLAUSE "autojorm" FROM CURRENT SYNTAX WITH

*3 ”%" AS A VARIABLE PLACE AND OPERATOR TOKEN AS ITS PLACE

*4 NAME THE CLAUSE BY A PRODUCTION AND SUBTERMNAME AS PARAMETERS

19 111107

Translaattorikehitin käy läpi kaikki termit tietokannassa ja rakentaa jokaisesta tietueen. Tietueella on muoto auto_form(Id-string, format-part). Merkki tarkoittaa paikkaa, sijoitetaan muuttuja koodin ' generointivaiheessa. Muotoilulauseet on rakennettu vastakkaisessa järjesteyksessä kieliopista ja 5 lyhennyksistä. Täten merkit It, eq, dot noteraataan. Stringit on nimetty siten, että on kaksi osaa: päätermi ja alaviivaja alatermin nimi (esimerkiksi command assignment is "command_assignment").

auto_form("command_assignment","% = %"). auto_form("commandJoop”, "repeat % until % < %").

10 autoJorm(,,expression_add","% + %“). auto_form("expression_value","%"). autojorm ("expression_nu mber". autojorm ("var_var","%").

15 10) Interaktiivisen kytkennän lopputuloksena syntynyt vastaavuustaulu eli konversio-ohjeet

Get-lauseet rakentuvat valmiiksi translaattorikehittimen käyttöliittymässä. Niiden muoto on seuraava: FOR EACH LINK OF FORMAT x(X) -> y(Y) GENERATE A GET-CLAUSE of FORMAT get_X_Y(X,Y):- SUBLCLAUSES!.

2 0 WHERE X AND Y ARE NON-TERMINALS WITH PARAMETERS ON NON-TERMINALS

AND SUBCLAUSES IS A LIST OF LOWER LEVEL GET_CLAUSES DERIVED FROM PARAMETER COMBINATIONS OF X AND Y.

(Lauseet Prolog-kielellä) 25 get_VAR_VARIABLE(var(STRINGl), variab(name(STRING1))):-1.

get_COMM AND_STATEMENT (assignment(VAR1 .EXPRESSION^, assignment_stmnt(assignment(VARIABLE1,Y_EXPRESSION2))):- get_VAR_VARIABLE(VAR1 .VARIABLE1), 30 get_EXPRESSION_EXPRESSION(EXPRESSION2,Y_EXPRESSION2),!.

get_COMMAND_STATEMENT(loop(PROGRAM1,VAR2,EXPRESSIONS), repeat_STMNT(loop(STATEMENTLIST1,less_than(EXPRESSION1,EXPRESSION2)))):- get_PROGRAM_STATEMENTLIST(PROGRAM1 .STATEMENTLIST1), get_VAR_EXPRESSION(VAR2,EXPRESSIONI), 35 get_EXPRESSION_EXPRESSION(EXPRESSION3,EXPRESSION2),!.

get_PROGRAM_STATEMENTLIST(Q,[]):-!.

get_PROGRAM_STATEMENTLIST([H1 IT1],[H2IT2]):- get_COMMAND_STATEMENT(H1, H2), get_PROGRAM__STATEMENTLIST(T 1 ,T2), !.

4 0 % Oletuskoodi PROGRAM -> STATEMENTLIST

20 111107 get_VAR_EXPRESSION(var(STRING1), name_expr(name(STRING1))):-!.

get_EXPRESSION_EXPRESSION(add(EXPRESSION1,EXPRESSION2), add(V_EXPRESSiON1,Y_EXPRESSION2)):- get_EXPRESSION_EXPRESSION(EXPRESSION1, Y_EXPRESSION1), 5 get_EXPRESSION_EXPRESSION(EXPRESSION2, Y_EXPRESSION2), !.

get_EXPRESSION_EXPRESSION(value(VAR1 ),name_expr(Y_NAME1 )):- get_VAR_NAME(VAR1, Y_NAME1), !.

10 get_EXPRESSION_EXPRESSION(number(INTEGER1), int(INTEGER1)):-!.

get_VAR_NAME(var(STRING1), name(STRINGI)):- !.

15 11) Lähtökielen Y kielioppia formaalina esityksenä 12) Kuvauskieleen (Prolog) muunnos PROGRAM = STATEMENTLIST BLOCK -> program(STATEMENTLIST, BLOCK)

20 BLOCK = void main IparARGLIST rpar COMPOUNDSTMNT

-> main(ARGLIST, COMPOUNDSTMNT), STATEMENTLIST -> statementlist(STATEMENTLIST) STATEMENTLIST = STATEMENT* 25 ST ATEMENT_TYPE = ;·< FUNCTION.DEFINITION semicolon -> fd(FUNCTION_DEFINITION), LABELED_ST semicolon -> ls(LABELED_ST), COMPOUNDSTMNT -> cs(COMPOUNDSTMNT), 3 0 EXPRESSION semicolon -> expr(EXPRESSION), SELECTION_ST semicolon -> ss(SELECTION_ST), ITERATION_ST semicolon -> is(ITERATION_ST), JUMP_ST semicolon ->js(JUMP_ST), DECLARATION semicolon -> declare(DECLARATION) 35 ITERATION.ST = do STATEMENT while Ipar EXPRESSION rpar

-> do(STATEMENT, EXPRESSION), while Ipar EXPRESSION rpar STATEMENT

4 0 -> while(EXPRESSION, STATEMENT), 21 111107

for Ipar EXPRESSIONLIST semicolon EXPRESSIONLIST semicolon EXPRESSIONLIST rpar STATEMENT

-> for(EXPRESSIONLIST, EXPRESSIONLIST, EXPRESSIONLIST, STATEMENT) ASSIGNMENT_EXPRESSION =

5 UNARY_EXPRESSION ASSIGNMENT_OPERATOR ASSIGNMENT_EXPRESSION

-> ase(UNARY_EXPRESSION, ASSIGNMENT_OPERATOR, ASSIGNMENT_EXPRESSION), CONDITIONAL_EXPRESSION

-> ce(CONDITIONAL_EXPRESSION), generate(GENEXPRESSION) 10 -> generate(GENEXPRESSION) GENEXPRESSION =

GENEXPRESSION questionm GENEXPRESSION

-> conditional_expr(GENEXPRESSION, GENEXPRESSION)

15 GENEXPRESSION LOG_OP GENEXPRESSION

-> logical_oper(GENEXPRESSION, LOG_OP, GENEXPRESSION) GENEXPRESSION MATH_OP GENEXPRESSION

-> math_oper(GENEXPRESSION, MATH_OP, GENEXPRESSION) GENEXPRESSION OP GENEXPRESSION 20 > relative_oper(GENEXPRESSION,OP,GENEXPRESSION) name(STRING) Ipar EXPRESSIONLIST rpar -> function_call(STRING, EXPRESSIONLIST) VAR -> var(VAR), CONSTANT -> const(CONSTANT) 25 ASSIGNMENTJDPERATOR = OP -> eq(OP), plus_eq -> plus_eq, minus_eq -> minus_eq 30 OP = eq -> eq, ne -> ne, gt ->gt,

It -> It, 35 ge -> ge, , le -> le 13) Y-kielen sanastoa tapahtuu muotoilulauseita käyttäen.

Ohessa otos sanastosta: 40 Y-kielen sanastoa ei tarvita, koska tulostus str_tok(";",semicolon) 22 111107 strjokf,", comma) str_tok("{”,lbr) str_tok("void",void) str_tok("}",rbr) str_tok("main",main) strJok(“:",colon) str_tok("(",lpar) str_tok("case",case) 5 str_tok(")",rpar) str_tok("default”,default) str_tok("if",if_) str_tok(''switch",switch) strJok(uelse'\else) str_tok(',goto,,,goto) str_tok(''do",do) str_tok("continue",continue) strJokC'while",while) str_tok("break", break) 10 str_tok("for",for) str_tok(''return",return) str_tok(''='',eq) 14) Y-kielen tietotwpit: 15 PROGRAM = program(STATEMENTLIST,BLOCK) BLOCK = main(ARGLlST,COMPOUNDSTMNT); stlist(STATEMENTLIST) 20 MAIN = main(DECLARATOR,ARGLIST) STATEMENTLIST = STATEMENT* STATEMENT = st(STATEMENTJYPE) 25 STATEMENT_TYPE = fd(FUNCTION_DEFINITION); ls(LABELED_ST); cs(COMPOUNDSTMNT); expr(EXPRESSION); 3 0 ss(SELECTION_ST); is(ITERATION_ST); js(JUMP_ST); declare(DECLARATION) 35 COMPOUNDSTMNT = stmntlist(STATEMENTLIST) SELECTION_ST = if_else(EXPRESSION,STATEMENT,STATEMENT); if_then(EXPRESSION,STATEMENT); switch(EXPRESSION, STATEMENT) 40 » 23 111107 ITERATION.ST = do(STATEMENT,EXPRESSION); while(EXPRESSION, STATEMENT); for(EXPRESSIONLIST,EXPRESSIONLIST,EXPRESSIONLIST,STATEMENT) 5 ASSIGNMENT.OPERATOR = eq(OP) ASSIGNMENT_EXPRESSION = ase(UNARY_EXPRESSION,ASSIGNMENT_OPERATOR,ASSIGNMENT_EXPRESSION); ce(CONDITIONAL_EXPRESSION); 10 generate(GENEXPRESSION) MATH_OP = plusQ; minus(); mpy(); 15 div_() EXPRESSION = asse(ASSIGNMENT_EXPRESSION); ce(CONDlTIONAL_EXPRESSION); generate(GENEXPRESSION) 20 EQUALITY_EXPRESSION = eq_rel(EQUALITY_EXPRESSION,RELATIONAL_EXPRESSION); relexp(RELATIONAL_EXPRESSION) RELATIONAL_EXPRESSION = lt(RELATIONAL_EXPRESSION,SHIFT_EXPRESSION); 25 gt(RELATIONAL_EXPRESSION,SHIFT_EXPRESSION); lt_eq(RELATIONAL_EXPRESSION,SHIFT_EXPRESSION); gt_eq(RELATIONAL_EXPRESSION,SHIFT_EXPRESSION); sh_exp(SHIFT_EXPRESSION) 3 0 SHIFT.EXPRESSION = left(SHIFT_EXPRESSION,ADDITIVE_EXPRESSION); right(SHIFT_EXPRESSION,ADDITIVE_EXPRESSION); add_exp(ADDITIVE_EXPRESSION) % « ADDITIVE_EXPRESSION = add(ADDITIVE_EXPRESSION,MULTIPLICATIVE_EXPRESSION); 3 5 sub(ADDITIVE_EXPRESSION,MULTIPLICATIVE_EXPRESSION); mult_exp(MULTIPLICATIVE_EXPRESSION) PRIMARY^EXPRESSION = var_expr(VAR); const(CONSTANT); 40 str(STRING,CURSOR); 24 111107 par_expr(EXPRESSION) VAR = var(STRING,CURSOR) 5 CONSTANT = null(); truej); false_(); ec(ENUMERATION_CONSTANT); i(INTEGER); 10 str(STRING)

Scannerin termit (Y-kieli) for(); eq(); 15 Y-kielessä ei käytetä scanneria, koska luku lbr(); tapahtuu X-kielellä. rbr();

Ohessa näyte scannerin termeistä. colon(); case(); P_TOK = semicolon(); default(); 20 comma(); switch(); void(); goto(); main(); continue(); lpar(); break(); rpar(); number(INTEGER); 25 if_(); true_(); else(); false_(); do(); op(OP); whileQ; nill 30 18) Y-kielen iäsennvsloaiikka Tätä ei tarvita esimerkissä, joten sitä ei esitetä.

18) Y-kielen aenerointikoodia

Seuraavassa esimerkissä tarvittava koodi kohdan 8 periaatteen mukaan gen_y_STATEMENTLIST(0,"").

gen_y_STATEMENTLIST([H], Str):- gen_y_STATEMENT(H, Str),!.

35 25 111107 gen_y„STATEMENTLIST([HIT], Str):- gen_y_STATEMENT(H, St1), gen_y_STATEMENTLIST(T, St2), format(Str,n% %", St1,St2).

gen_y_STATEMENT(cs(COMPOUND_STl) ,Str):-5 gen_y_COMPOUND_ST(COMPOUND_ST1 ,Str1), * SList =[Str1], gen_y_output(SList, "statement_cs", Str),!.

gen_y_STATEMENT(e$(EXPRESSION„ST 1) ,Str):-10 gen_y_EXPRESSION_ST(EXPRESSION_ST1,Str1), SList =[Str1], gen„y_output(SList, "statement_es", Str),!.

gen_y_STATEMENT(is(ITERATION_STl) ,Str):-15 gen_y_ITERATION_ST (ITERATION_ST 1 ,Str1), SList =[Str1], gen„y_output(SList, "statementjs", Str),!.

gen_y_ITERATION_ST(do(STATEMENT1 ,EXPRESSION) ,Str):- 2 0 gen_y_STATEMENT(STATEMENT 1 ,Str1), gen_y_EXPRESSION(EXPRESSION2,Str2), SList =[Str1,Str2], gen_y_output(SList, "iteration_sLdo”, Str),!.

25 gen_y_ASSIGNMENT_OPERATOR(eq(OP1) ,Str):-gen_y_OP(OP1 ,Str1), :*· SList =[Str1], gen_y_output(SList, "assignment_operator_eq", Str),!.

3 O gen_y_ASSIGNMENT_EXPRESSION(ase(UNARY_EXPRESSION1, ASSGNMENT_OPERATOR2,ASSIGNMENT_EXPRESSION3) ,Str):-gen_y_UNARY_EXPRESSION(UNARY_EXPRESSION1 ,Str1), gen_y_ASSIGNMENT_OPERATOR(ASSIGNMENT_OPERATOR2,Str2), gen_y_ASSIGNMENT_EXPRESSION(ASSIGNMENT_EXPRESS!ON3,Str3), 35 SList =[Str1 ,Str2,Str3], gen_y_output(SList, "assignment_expression_ase", Str),!.

gen_y_EXPRESSION(asse(ASSIGNMENT_EXPRESSION1) ,Str):· gen_y_ASSIGNMENT_EXPRESSION(ASSIGNMENT_EXPRESSION1 ,Str1), 40 SList =[Str1], 26 111107 gen_y_output(SList, "expression_asse", Str),!.

gen_y_VAR(var(STRING1,_) ,Str):-gen_y_STRING(STRING1 ,Str1), 5 SList =[Str1 ], gen_y_output(SList, "var_var", Str),!.

gen_y_CONSTANT(i(INTEGER1) ,Str):-str_int(Str1 JNTEGER1), 10 SList =[Str1], gen_y_output(SList, "constantJ”, Str),!.

gen_Y_GENEXPRESSION(math_oper(GENEXPRESSION1,MATH_OP2, GENEXPRESSION3),Str):- 15 gen_Y_GENEXPRESSION(GENEXPRESSIONl ,Str1), gen_Y_MATH_OP(MATH_OP2,Str2), gen_Y_GENEXPRESSION(GENEXPRESSION3,Str3), SList =[Str1 ,Str2,Str3], gen_output(SList, "genexpression_math_oper“, Str), 20 ! .

gen_Y_GENEXPRESSION(relatiV0_oper(GENEXPRESSION1,OP2,GENEXPRESSION3) ,Str):-gen_Y_GENEXPRESSION(GENEXPRESSION1 ,Str1), gen_Y_OP(OP2,Str2), 25 gen_Y_GENEXPRESSION(GENEXPRESSION3,Str3), SList =[Str1 ,Str2,Str3], ’’ gen_output(SList, "genexpression_relative_oper", Str), I.

30 gen_Y_GENEXPRESSION(var(VAR1) ,Str):-gen_Y_VAR(VAR1 ,Str1), SList =[Str1], ·. gen_output(SList, "genexpression_var", Str),!.

3 5 gen_Y_GENEXPRESSION(const(CONSTANT 1) ,Str):-gen_Y_CONST ANT(CONSTANT1 ,Str1), SList =[Str1], gen_output(SList, "genexpression_const", Str),!.

40 gen_Y_MATH_OP(plus,"+").

27 111107 gen_Y_OP(eq,"=").

Alla vielä muotoilutoiminnot, jotka ovat kieliriippumattomia (yleistyökalu): 5 gen_output(Slist, Form, Str):-auto_form(Form, StrF), format_loop(Str, StrF, SList), I. gen_output(Slist, Form, Str):-format(Txt,"\n Form), 10 gen_slist_Str(SList, Txt, Str),!. gen_output(Slist, Form, Str):-not(auto_form(Form, _)), gen_slist_Str(SList,",",Str).

15 19) Y-kielen muotoilulauseita

Ohessa näytteet muotoilulausekkeista: auto_form("program_program","% %"). auto_form("block_main","void main (%) %"). auto_form("block_stlist","%").

20 auto_form("main_main","% main (%)"). auto_form("statement_st","%;"). auto_form("statement_typeJs","%"). auto_form("statement_type_cs","%"). auto_form("statementJype_expr","%").

2 5 auto_form("statement_typeJs'',''%").

;· auto_form("compoundstmnt_stmntlist","{ %}").

auto_form("selection_st_if_else"/'if (%) % else %"). auto_form("selection_st_if_then","if (%) %"). auto_form("selection_st_switch","switch (%) %").

3 o auto_form("iteration_st_do","do % while (%)").

auto_form("iteration_st_while","while (%) %"). auto_form("iteration_st_for","for (% ; %; %) %").

’ - auto_form("assignment_operator_eq","%").

auto_form("assignment_expression_ase","% % %").

3 5 auto_form("assignment_expression_ce'',"%"). auto_form("assignment_expression_generate","%"). auto_form("genexpression_math_oper","% % %"). autoJorm("genexpression_relative_oper","% % %"). auto_form("genexpression__var","%").

28 111107 auto_form("genexpression_const","%"). auto_form("expression_asse","%"}. auto Jorm (“ expression_ce" auto_form("expression_generate","%").

5 auto_form("constant_expression_cond","%"). auto_form("relational_expressionJt","% < %"), auto_form("relationaLexpression_gt",''% > %"). auto_form("relational_expression_lt_eq","% <= %"). auto_form("relational_expression_gt_eq","% >= %").

10 auto_form("relational_expression_sh_exp","%"), « « ·

Claims (7)

111107

1. Menetelmä translaattorin kehittämiseksi, joka translaattori on tarkoitettu konvertoimaan tulokielisen koodin lähtökieliseksi, ja jossa menetelmässä käytetään kuvauskieltä (V) kahden toisistaan 5 riippumattoman lähdekielen, nimittäin sanottujen tulokielen (X) ja lähtökielen (Y) formaaliin kuvaamiseen , kunkin lähdekielen käsittäessä formaalisia päätermejä (X„Yj) ja kussakin päätelmissä yksi tai useampia esiintymiä ja näissä mahdollisia parametrejä, ja jossa translaattoriohjelmaa varten muodostetaan käännösinformaation sisältävät tiedostot ja käännetään translaattorin sovelluskoodi valitulle käyttöjärjestelmälle, ja lopuksi sovelluskoodi ja tiedostot linkataan yhteen, 10 tunnettu siitä, että menetelmään kuuluu seuraavat vaiheet: - molempien lähdekielien (X ja Y) kieliopit tallennetaan valitulla formaatilla tiedostoihin siten, että kunkin lähdekielisen päätermin kaikki esiintymät eritellään (vaiheet 1 ja 1'), - molemmista lähdekielistä (X ja Y) muodostetaan kuvauskieliset muunnokset (VX ja VY) tietokantaan, jossa kuvauskielessä kunkin termin esiintymä (VXi.VYj) ilmoitetaan semanttisesti valitun kuvauskielen 15 termin (Vk) ja lähdekielen määriteltyjen termien avulla, (vaiheet 2 ja 2'), - kuvauskielisistä tulo- ja lähtökielen muunnoksista (VX) ja (VY) sekä tallennetuista lähdekielien (X ja Y) kieliopeista muodostetaan translaattorille tarvittavia aputiedostoja VX(a-e) ja VY(a-e), kuten esimerkiksi (vaiheet 3 ja 3') a) sanasto ja skannerin termit 20 b) tietotyypit c) jäsennyslogiikka d) generointikoodi e) muotoilulausekkeet - suoritetaan interaktiivinen kunkin muunnetun tulokielen termin VX| liitäntä valittuun lähtökielen 25 muunnettuun termiin VYn käsittäen portaittain (vaiheet 4 ja 5): - päätermien kytkennän tosiinsa - esiintymien sovituksen toisiinsa, ja - tallennetaan kunkin muunnetun tulokielen termin (VX,·) konversio-ohje (VX»VY) tiedostoon.

2. Patenttivaatimuksen 1 mukainen menetelmä, tunnettu siitä, että tallennetaan tietokantaan tai vastaavaan translaattoria varten: - tulokielen jäsennyslogiikka (VX(c)) ja - tarvittava lähtökielen generointikoodi (VX(d)) ja - - - konversio-ohjeet (VX*VY) ja 5. tarvittavat lähtökielen muotoilulausekkeet (VY(e)), jolloin translaattori voi muodostaa jäsennyslogiikan , (VX(c)) ja käännettävän tulokielisen koodin avulla jäsennyspuun (vaihe 9) käsittäen koodin kuvauskielisessä muodossa ja konvertoida koodin konversio-ohjeiden (VX*-VY) avulla lähtökielen kuvauskieliseen muotoon (vaihe 10) ja generoida sekä muotoilla kuvauskielisen koodin lähtökielen koodiksi (vaihe 11) lähtökielen generointi ja muotoilulausekkeiden (VY(d,e)) avulla. 40 111107

3. Patenttivaatimuksen 1 tai 2 mukainen menetelmä, tunnettu siitä, että interaktiivisessa kytkennässä käytetään päättelykonetta, joka käyttää hyväksi yhtä tai useampaa seuraavaa kriteeriä: - ehdotetaan aikaisemmin kytkettyjä esiintymiä keskenään yhteen, - ehdotetaan kuvauskielen termien perusteella samannimisiä esiintymiä/parametrejä yhteen, 5. ehdotetaan järjestyksen perusteella parametrejä keskenään yhteen.

4. Jonkin patenttivaatimuksen 1 - 3 mukainen menetelmä, tunnettu siitä, että interaktiivinen liitäntä suoritetaan graafisella käyttöliittymällä käsittäen ainakin valintaikkunat ehdotettaville termeille, muodostuvalle konversio-ohjeelle, sekä ainakin yhden ponnahdusikkunan valintalistalle ja jossa 10 kussakin valintaikkunassa kukin komponentti toimii linkkinä vastaavaan esille tulevaan valintalistaan.

5. Jonkin patenttivaatimuksen 1 - 4 mukainen menetelmä, tunnettu siitä, että kuvauskielenä ja/tai translaattorin lähdekielenä käytetään PROLOG-kieltä. 15 6. Järjestelmä tietokoneohjelman kääntämiseksi ensimmäisestä lähdekielestä eli tulokielestä (X) toiseen lähdekieleen eli lähtökieleen (Y), johon järjestelmään kuuluu - syöttötiedosto (7) käsittäen useita koodirivejä sisältävän tulokielisen tietokoneohjelman, - translaattori (X>Y) kytkettynä syöttötiedostoon (7), joka translaattori lukee syöttötiedostoa ja generoi tietokoneohjelmasta käännetyn version, ja jossa translaattoriin kuuluu konversio-ohjeet (VX*-VY, 41) 2. liittyen kuhunkin tulokieliseen termiin, - käännetty tiedosto (12) kytkettynä translaattoriin (X>Y) täten generoidun tietokoneohjelman käännetyn version vastaanottamiseksi, - toimenpidekirjasto, jossa on translaattorista (X>Y) kutsuttavia rutiineja, tunnettu siitä, että järjestelmään kuuluu myös: 25. ensimmäinen aputiedosto (X(c), 31c) sisältäen tulokielen jäsennyslogiikan valitulle semanttiselle kuvauskielelle (V), ;· - toinen aputiedosto (P(Y(d,e), 42), sisältäen lähtökielen generointi- ja muotoilulausekkeet; jolloin translaattori (X>Y) on sovitettu: - konvertoimaan tietokoneohjelman koodirivit ensin kuvauskieliseen muotoon käyttäen ensimmäisen 3. aputiedoston VX(c) jäsennyslogiikkaa, (vaihe 9); ja - sitten konvertoimaan ne kuvauskielisessä muodossa käyttäen sanottua konversio-ohjetta (VX>-VY,41), (vaihe 10) ja - generoimaan ja muotoilemaan kuvauskielinen koodi formaaliksi lähtökielen koodiksi (vaihe 11) käyttäen lähtökielen generointikoodia (VX(d), 42) ja muotoilulausekkeita (VY(d), 42). 35

7. Vaatimuksen 6 mukainen järjestelmä, tunnettu siitä, että lähtökieli (Y) on valitun muotoinen dokumentointiformaatti tulokielisen (X) ohjelman automaattiseksi dokumentoinniksi, esimerkiksi jollain seuraavista formaateista: modulilistaus, muuttujaluettelo, ristiviitetaulu, graafinen hierarkiakaavio, tiedonkulkukaavio. 40 111107