<--  | Ana Sayfa  | Erişimdüzeni  | İçindekiler  | Arama

Emre Demiralp <emre(at)kardelen.fe.itu.edu.tr> Yazar hakkında: Ben, İstanbul Amerikan Robert Koleji'nde öğrenci olmakla birlikte, aynı zamanda, İstanbul Teknik Üniversitesi'nin Fen-Edebiyat Fakültesinin bilgisayar labaratuvarının yöneticilerinden biriyim. Bu labaratuvarlarda en çok kullanılan işletim sistemi LINUX. İlgi Alanları: PovRay ve PostScript, animasyon, CD dizaynı, programlama, holografi vb. 1994'ten beri LINUX kullanmaktayım. Türkçe'ye çeviri: Resul Dilsiz <resul/at/be.itu.edu.tr> İçerik: Giriş Dizeler ve Dize Operatörleri Anahtarlar ve Değişkenler Döngüler (Loops) Procedure or Macro Definitions (İşlem veya Makro Tanımları) Exercises

Postscript III:PostScript'in İşlenen Yığını: Diziler, Değişkenler, Döngüler ve Makro Tanımlama Özet: Çok bilen kişi, aynı zamanda çok başarısız olur. -Türk Atasözü-. Yazar, PostScript dilinin işlene yığınlarını anlatmaya devam ediyor. Dizelerin tanımları, dize operatörleri, değişkenler, döngüler, ve makro tanımlamalarının hepsi burada, yeterli detay, açıklayıcı örnekler ve bir sonraki makalede yanıtlanacak olan sorularla anlatılmıştır. Bu makale, işlenen yığınlarını anlatmaya tek başına yeterli değildir. Hikaye, gelecek makalelerde devam edecektir. _________________ _________________ _________________

Giriş

Bu PostScript ile alakalı makaleler serisinin üçüncüsüdür. PostScript'in işlenen yığınlarını anlatmaya devam ediyoruz. Dizelerin, dize operatörlerinin, değişken tanımlamalarının, döngülerin ve makro tanımlamalarının altını çiziyoruz. Bu konular hakkında önemli noktaları sunmak istiyoruz. Sunum ayrıca öğretici örneklerle zenginleştirilmiştir. İşlenen yığınları, değişik konularda yazılan gelecek makalelerde devam edecektir.

Dizeler ve Dize Operatörleri

Bu serinin önceki makalelerinde, işlenen yığınlarını yapısına ve işlenen yığınların yapısını değiştirebilen operatörlere değinmiştik. Hatırlayacağımız gibi, işlenen yığında tutulan büyüklüklerin hepsi, işlenen yığında referans noktası yaratmaya yarayan özel bir eleman hariç, tamsayılardı. Bu elemanlar, -marktype- olarak adlandırılırdı. cleartomark ve counttomark operatörleri, işlenen yığının başından bu işaretlere kadar olan elemanları saymak veya silmek üzere kullanılırdı. Tabii ki de, bu bir gruplama kolaylığıdır fakat, tek gruplama kolaylığı bu değildir. Birçok element barındıran tek bir varlık da yaratmak mümkündür. Bu varlık dize olarak adlandırılır ve dizelerin elementleri üzerinde PostScript dilinin dize operatörleri ile işlem yapmak mümkündür. Dize operatörlerini sıralayarak, bu dize operatörleri hakkında detay bilgiler ve açıklayıcı örnekler sunacağız.

[  :Bu, yığında bir marktype elementi yaratır. Eşi olan ] işareti girilmezse, mark komutu ile aynı işi görür. Bu operatörden sonra işlenen yığına giren her element, işlemci yığınında, kendilerinden önce işaretlenmiş bir referans noktası olduğu halde, ayrı elemanlar olarak kabul edilir. Aşağıdaki oturum, [ ve mark arasındaki ilişkiyi açıklar:

GS>[ pstack
-marktype
GS<1>2 3 mark pstack
-marktype-
3
2
-marktype-
GS<4>

]  :Bu, yukarıdaki [ operatörünün eşidir. Yığın, bu element verilmeden önce girilmiş bir marktype elementi içermelidir. Aslında bu, dizenin sonlandırıcı işaretidir ve dize yapımını tamamlar. Her bitişin bir başlangıcı olduğu için, PostScript işaretin eşini, ] başlangıç işaretini arar. Eğer [ işareti bulunamazsa, PostScript hata verir ve istenen işlem yapılmaz. Eğer bu eleman hemen ['ın peşine girilmişse, boş bir dize yaratılır ve işlenen yığınında tek bir varlık gibi tutulur. Aşağıdaki oturumun gösterdiği gibi:

GS>[ pstack
-marktype-
GS<1>] pstack
[]
GS<1>

Bunların ardından, işlenen yığını, sadece bir eleman içerir: boş bir array. Boş olmayan bir dize, [ ve ] arasına dize elemanları direkt girilerek tek girdide aşağıdaki oturumda görüldüğü gibi yaratılabilir.

GS>[ 1 2 3 ] pstack
[1 2 3]
GS<1>

Gördüğümüz gibi, dizemiz sadece bir varlık gibi kabul edildi.

Dizeleri, her elementi belirlemeden, sadece içerdiği eleman sayısını belirterek de yaratbiliriz. Bu, nothing anlamına gelen null elemanıyla yapılır.

GS>[ null null ] pstack
[null null]
GS<1>

array:(dize:) Bu komut için, tamsayı bir parametre gereklidir. parametre n ise, komut n array olarak girilir. Yapıldığında, tam olarak n adet null element içeren bir dize yaratılır. Dize yaratmanın başlangıç ve bitiş işaretlerinin yaptığının aynısını yapar. Örneğin, 3 array, [ null null null ] ile aynıdır. Parametresini, işlenen yığının en başında arar. Eğer komuttan önce girilmişse, işlenen yığınına girer ve komut tarafından alınan ilk eleman olur. Eğer parametre girilmemişse, işlenen yığının başındaki eleman ne olacağını belirler. Bu eğer bir tamsayıysa, komut tarafından kullanılır, eğer değilse uyumsuzluktan kaynaklana bir hata mesajı görüntülenir.

length:(uzunluk:)Bu operatör, dizedeki elemanların sayısını döndürür. null elemanlar da sayılmaktadır. Operatör, parametre olarak dize alır. Operatör, parametresini işlenen yığınının başındaki eleman olarak alır. Parametre, işlemin gerçekleşmesiyle birlikte, işlenen yığınından kaybolur. Bu yüzden, eğer parametre komuttan önce girilmişse ve bu bir dizeyse, herşey iyi gider ve işlenen yığınının başındaki eleman tespit edilir. Örneğin:

GS>[ 1 2 3 4 5 ] length pstack
5
GS<1>

length operatörü için parametre vermezsek, ya komut tarafından işlenen yığınının başındaki eleman kullanılır, işlenen yığınından atılır ve dizedeki eleman sayısı işlenen yığınının başına yerleştirilir,

GS<1>pstack
[1 2 3 6 7]
GS<1>length pstack
5
GS<1>

ya da o anki işlenen yığınının başındaki eleman dize değildir ve bir hata mesajı görüntülenir.

get:(al:)Bu operatör iki parametre alır. İlk ve ikinci parametreler sırasıyla dize ve tamsayıdır. Operatör dizeden belirtilen elemanı alır. Alınacak elemanın pozisyonu, operatörün ikinci parametresidir. Pozisyonlar doğal sayılarla dizinlenmiştir, yani sıfırdan başlarlar. Aslında bu kural her operatör parametreleri için geçerlidir. Parametreler komut tarafından kullanılır ve işlenen yığınından atılırlar. Verilen parametrelerinin türleri uyuşmalıdır. Bu noktada daha fazla ayrıntı vermiyoruz. get'in kullanımı aşağıdaki gibidir.

GS[1 6 3 0 9] 0 get pstack
1
GS<1>

put:(koy:)Bu komutun üç parametreye ihtiyacı vardır. Bunlar, sırasıyla dize, dizin ve dizenin arasına sokulacak elemandır. Çalıştırıldığında komut, ilk parametre tarafında verilen dizeyi alır, dizini ikinci parametreyle verilen pozisyondaki elemanı bulur ve bu posizyondaki dize elemanını üçüncü parametrede girilen şey ile değiştirir. Sonuç dizesi, işlenen yığınında tutulmaz. Bu yüzden put operatörünün kesin kullanımı için, dize değişkeni tanımlayabiliriz (ya da PostScript terminolojisinde bir anahtar). Uygulama bu değişken üzerinde yapılır ve sonuç sonra işlenen yığınına girer ve oradan gösterilir. Aşağıdakini inceleyiniz.

GS>[1 2 3] 0 8 put
GS>

Burada işlenen yığınında hiçbirşey olmuyor. Ama hata mesajı da görüntülenmiyor. Aslında, put komutu yapması gerekeni yapıyor ama sonuç işlenen yığınında tutulmuyor. Aynı işlemin sonucunu işlenen yığınında tutabilmek için aşağıdaki oturumu inceleyiniz:

GS>/ar [ 1 2 3 ] def
GS>ar 0 8 put
GS>ar pstack
[8 2 3]
GS<1>

Burada önce dize değişkeni (Türkçesi) ya da anahtar (PostScript'çesi) tanımlanıyor. Değişken ismi ar. İkinci adımda dizinin ilk elemanını (dizini sıfır) put operatörünü kullanarak 8 ile değiştiriyoruz. Bundan sonra ar pstack komutu, ar değişkenini işlenen yığınına alır ve içini gösterir. değişken tanımlama konusuna bu makalede daha sonra değinilecektir. Ayrıca, bu serinin gelecek makalelerinde sözlükler ve sözlük yığınları konusuna da değinilecek.

getinterval:(aralıkal:)Bu operatör, verilen bir dizeden bir alt-dize yaratır. Üç parametreye ihtiyaç duyar. Bunlar sırasıyla, alt-dizenin yaratılacağı dize, alt-dizenin ilk elemanı olacak dizin ve alt-dizenin eleman sayısını belirten tamsayı. Çalıştırıldığında, komut, ilk parametrede verilen dizeden, ikinci parametrede verilen dizinden başlamak suretiyle, üçüncü parametrede verilen sayı kadar eleman alır ve bunları yeni bir dizeye kopyalar. Yeni dize, işlenen yığınına eklenir. Örneğin,

GS>[1 2 3 4 5 6 7 8 9] 2 3 getinterval pstack
[3 4 5]
GS<1>

putinterval:(aralıkkoy:)Bu, verilen dizenin bir alt-dizesini belirtilen başka bir dize ile değiştirir. Üç parametre gereklidir: İlki, alt-dizesi değiştirilmek istenen dizedir, ikincisi, değiştirilmek istenen alt-dizenin pozisyonunu belirten alt-dizedir ve üçüncüsü verilen dizede değiştirilmek istenen alt-dizenin yerine yerleştrilecek olan alt-dizedir. Komut, put komutuna çok yakındır. İşlenen yığınına sonuç döndürmez. Sonucun nasıl görüntülendiğini görmek için, aşağıdaki oturumu inceleyiniz:

GS>/ar [1 2 3 4 5 6 7 8 9] def
GS>ar 3 [0 0 0] putinterval
GS>ar pstack
[1 2 3 0 0 0 7 8 9]
GS<1>

aload:(dize yükle:)Bu, parametre olarak dize alır ve bu dizenin elemanlarını tek girdiler olarak işlenen yığınına kopyalar. Çalıştırıldıktan sonra işlenen yığınının başındaki elemen dizedir.Bu da:

GS>[1 2 3] aload pstack
[1 2 3]
3
2
1
GS<4>

astore:(dize sakla:)Bu komut, ikinci parametrede verilen dizenin tüm elemanlarını, işelenen yığınından aldığı aynı sayıda elemanla değiştirir. Sonuç, yer değiştirilmiş olan elemanları içeren, yeni dizedir.

GS>1 2 3 [null null null] astore pstack
[1 2 3]
GS<1>

copy:(kopyala) Bu, ilk parametrede belirtilen dizeyi, ikinci parametrede belirtilen dizenin başına kopyalar. Görüntülenen sonuç, ikinci dize değil, kopyalanan alt-dizedir. İkinci dizenin son halini görebilmek için aşağıdaki değişken tanımlaması kullanılabilir.

GS>[1 2 3] [4 5 6 7 8] copy pstack
[1 2 3]
GS<1>/ar [4 5 6 7 8] def
GS<1>[1 2 3] ar copy
GS<2>ar pstack
[1 2 3 7 8]
[1 2 3]
[1 2 3]
GS<3>

Dize elemanlarının tamsayı olmaları şart değildir. Karakter dizgisi de olabilir. Bu da, dizelerin birbirinin içine geçmiş yapısına, PostScript'te izin veriliyor demektir. Bu avantaj, dizey işlemlerini ve dizeyler üzerinde makro tanımlamalarını kullanmamıza izin verir. Üçten fazla elemana dayanarak tanımlanabilen vektör nicelikleri veya çok-boyutlu dizilerle uğraşmak bile mümkündür. Şimdilik bu kadar bilgi yeterli olacaktır.

Anahtarlar ve Değişkenler

Her programlama dilinde, değişken tanımlamak mümkündür. Değişken tanımlamak, büyüklükleri, içinde tuttukları büyüklüklerin hafızanın neresine yazılı olduğunu düşünmeden kullanabilme imkanı verir. Hafızanın belli bir kesiminde saklanmış olan değere, o kesimin adresini vermek veya içeriği için bir anahtar girmek vasıtasıyla ulaşılabilir. İlk yaklaşım, C'de olduğu gibi, işaretçiler kullanmaktır. Adreslerle ilişiğinizin bulunmamasını dilerseniz, anahtar kullanmak sizin için yeterli olacaktır. Mamafih, bu durumda hafıza erişimi ve diğer işlemler ile dilin derleyicisi veya yorumlayıcısı ilgilenmek durumundadır. Bunun için siz sadece bir karakter dizgisi, bir kelime girip, bu varlığa değer atarsınız. Bütün bu işlemler aslında sizin bakış açınızdan programlama diline, değişkenin ne olduğunu söylemek ve bu değerin ne olduğunu söylemektir. Derleyici veya yorumlayıcı bir hafıza kesimini değişkeniniz için belirler ve bundan sonra değişkeninize yapılan bütün atamalar, bu adrese veri olarak gönderilir. PostScript'te de buna yakın bir yapı vardır. PostScript, içinde isimler, anahtarlar ve ilgili tanımlamaları barındıran sözlüklere haizdir. PostScript terminolojisinde, bir sözlük, ilk teki key (anahtar) olarak adlandırılan, ikinci teki de value (değer) olarak adlandırılan çiftlerden oluşmuştur. Örneğin, add (ekle) aritmetik toplama işlemi (value) yapan bir isimdir (key). PostScript add komutunun anlamını bilmektedir, çünkü bu bilgi systemdict adı verilen bir sözlükte saklanmaktadır. Eğer 1 2 add pstack komutunu girerseniz, sonuç olarak 3 görürsünüz, çünkü PostScript bu üç isme bakar ve şunları yapar: 1, 2 ve add kelimelerini işler. İlk iki nesne tamsayıdır, bu yüzden işlenen yığınına atılırlar. Üçüncü nesne ise bir yazı karakteri dizisidir ve bir isim (key) olabilir de olmayabilir de. PostScript, sözlüklerinde bu ismi arar. add ismi, systemdict sözlüğünde bulunduğu için bu isim (key) için bir eylem (value) vardır. Bu eylem, sırasıyla, işlenen yığınının en üstündeki iki elemanı almak, bunların aritmetik toplamını hesaplamak ve sonuç elemanını işlenen yığınının başına koymaktır. Komutun geri kalan kısmı ise pstack tır ve bu da sistem sözlüğünde yer almakta olup, PostScripte, işlenen yığınının başındaki elemanı standart çıktı birimine yazdırmasını söylemektedir. Diğer yandan yorumlayıcıya komut olarak -bilerek veya yanlışlıkla 1 2 dad pstack yazabilirdik. Bu durumda yorumlayıcı, PostScript sözlüklerinde dad gibi bir anahtar veya isim bulamadığına dair bir hata verecekti.

Ayrıca PostScript'in sistem sözlüğündeki tanımlar ile sınırlı değiliz. Kullanıcı tanımlı komutlar olarak kimlik ve prosedürler tanımlamak mümkündür. Yaptığımız bir kimlik tanımlaması ise isim veya anahtarı, PostScript terminolojisinde olmamasına rağmen değişken(variable) olarak çağırırız. Buradaki amacımız, diğer çok bilinen programlama dillerinde olduğu gibi yeniden çağırma işlemleri yapabilmektir. Değişken tanımlamak için tek yapmamız gereken, /x value def yazmaktır. Burada value tamsayı, dize, karakter dizesi gibi, herhangi bir PostScript nesnesidir. Örneğin, yorumlayıcıya /x 12 def girdiğimizi kabul edelim. Yorumcu, üç nesneyi işler: /x, 12 ve def. / işareti ile başlayan nesneler, anahtar veya isim olarak kabul edilirler. Bunlar, işlenen yığınına, sözlükte olsalar da olmasalarda sözlüğe eklenir. def komutu da anahtar-değer çifti olarak işlenecek bir komut olarak sistem sözlüğünde tanımlanmıştır. İlk işleneni anahtar olarak kabul eder ve ikinci işleneni bu anahtara atanacak değer olarak kabul eder. Bu yüzden PostScript, bu komutun ardından anahtar-değer(key-value) çifti oluşturur ve /x 12 def komutunun tamamlanmasıyla yapılan bu tanımlamayı, geçerli sözlük(current dictionary) adı verilen özel varsayılan bir sözlüğe ekler. Bu kayıt, sözlük yığınının en üstündeki elemanı olur (bu konuya ilerideki makalelerde değinilecektir). Bu noktadan sonra, bütün oturum boyunca x PostScript tarafından 12 olarak tanınacaktır.

Prensip olarak, / işaretiyle başlayan herhangi bir karakter dizesi, anahtar olarak kullanılabilir. Ancak, numaralar ve harflerin dışında kalan karakterleri değişken ismi olarak kullanmaktan kaçınmak gerekir. Aksi halde, noktalama işaretleri, aritmetik operasyon işaretleri vb. karakterler, istenmeyen eylemlerin gerçekleşmesine neden olabilirler çünkü bu karakterlerin PostScript dillerinde farklı anlamları vardır. Değişken ismi olarak kullanacağınız karakter dizesinin limiti, yorumlayıcınızın kapasitesiyle belirlenir. Aslında anahtar ismi olarak yüzlerce karakterden oluşan karakter dizeleri kullanmak, mümkün olsa bile uygun değildir. PostScript küçük-büyük harf duyarlı olmasındans sebep, anahtar isimlerinde yeterince esneklik sağlamaktadır. Anahtar isimleri PostScript'in sistem anahtarlarında seçilmemelidir. Aksi halde, yeni anahtar, sistem komutunun üzerine yazılacaktır ve bu istenmeyen bir durumdur. Örneğin, /add 13 def komutunu çalıştırdıktan sonra, add anahtarı bir sabit değere dönüşmüştür ve bu noktadan sonra oturumda toplama işlemini sağlıklı bir şekilde yapmak mümkün olmayacaktır. Bu konuda söylenecek çok şey olmasına karşın, şimdilik birkaç paragrafla yüzeysel bir anlatım yapıp, kalanı gelecek makalelerde anlatılacaktır.

Döngüler (Loops)

PostScript, döngüler adı verilen, tekralama amaçlı yapılara sahiptir. Aynı türden işlemleri tekrar tekrar yapmayı sağlar. Yinelenecek olan işlemlerin sayısı binler, milyonlar, milyarlar veya katrilyonlar olabilir. Hiç farketmez. Sadece bir komutla bütün prosedür, döngülerle çalıştırılabilir. İlerleyen satırlarda döngüler ve döngü komutları hakkında konuşacağız.

repeat: (tekrar et:)Bu komut, iki parametreye ihtiyaç duyar. İlki sade bir tamsayıdır ve işlemin ne kadar yineleneceğini belirtir. İkinci ise genellikle eylemler bloğundan oluşan bir prosedürdür. PostScript'te blok, { ve } işaretleri ile sınırlandırılır. Emirler ve komutlar, sırayla bu işaretlerin arasına konar. Komutun sözdizimi n { ... } repeat gibidir. Bu emir verildiğinde, PostScript, ilk parametreyi alır ve işlenen yığınının başına yerleştirir. Daha sonra { ... } bloklarıyla verilen prosedür okunur. Sonunda repeat sistem sözlüğünden okunur ve tanımladığı işlemler gerçekleştirilir. Komutun tanımladığı işlemler sadece tekrarlamak olduğundan, ikinci parametre oalrak veilren prosedür n defa çalıştırılır. Detaya inersek, şu örneği verebiliriz:

GS>3 {1} repeat
1
1
1
GS<3>

Bu komutla, üç tamsayı değeri, 1, işlenen yığınına sokulur. Aslında buradaki prosedür çok basittir: sadece 1 girmektir. Daha karmaşık olarak aşağıdaki prosedürleri verrebiliriz:

GS>1 5 {1 add} repeat pstack
6
GS<1>

Bu örnekte önce,1 işlenen yığınına girer, sonra {1 add} işlenen yığınında 5 kere çalıştırılır. 5 adım şöyle çalışır. İlk adımda, 1 add çalıştırılır. add iki parametreye ihtiyaç duyar, ikincisi, prosedürün kendisinde verilmiştir ve 1'dir. İlk parametre ise, (veya PostScript terminolojisinde işlenen(operand)) işlenen yığınından alınır. Bundan dolayı, tekrarın ilk adımında 1 1 add çalıştırılır. İşlenen yığınının tek elemanı olan 1, bu işlemden sonra silinir ve 2 olan sonuç, işlenen yığınının en üstüne sokulur. Sonra ikinci adımda 2 1 add komutu çalıştırılır ve sonuç, tek elemanlı işlenen yığını, 3 olarak işlenen yığınına yazılır. Böylece üçüncü adıma 3 1 add işlemi kalır. Diğer iki adım ise 4 1 add ve 5 1 add'dir. Bu yüzden işlenen yığını, komut çalıştırıldıktan sonra, sadece 6'yı içermektedir.

for:Bu komut tekrarlamalı prosedürlerin uygulanmasında, tamsayı bir kontrol değişkeni kullanır. Kontrol değişkeni, bir başlangıç değerinden başalr ve değerini prosedürün her ayrı çalıştırılmasından sonra değiştirir. Bu eylem, daha önceden belirlenen değer aşılana kadar devam eder. Bu yüzden, bu komut, dört işlenene ihtiyaç duyar, ilk üç tanesi sırasıyla, başlangıç(Initial), artış(Increment), ve limit(Limit)'tir. Bütün bu üç parametrenin, sayısal değer olması beklenir: tamsayı veya ondalık sayı. Dördüncü işlenen ise, tek bir komuttan oluşabileceği gibi { ... } formatında komut blokları halinde de girilebilecek prosedürdür. Komutun tam sözdizimi, başlangıç artış limit {komut} for 'dur. Komut çalıştırıldığında, PostScript, geçici bir sayaç değişkeni (PostScript terminolojisinde kontrol değişkeni) yaratır ve onun değerini başlangıç değişkenine eşitler. Bu değer, işlenen yığınına sokulur, {komut} tarafından işlenen olarak kullanılır veye kullanılmaz. Kullanılırsa, işlenen yığınından atılır, aksi halde işlenen yığınında kalır. Sayaç değişkeni başlangıç'a eşitlendikten sonra, {komut} çalıştırılır. Bunun hemen ardından sayaç değişkeninin değeri artış ile toplanır. Döngü daha sonra, bu şekilde, yeni artırılmış kontrol değişkeninin değeri limit değeri aşana kadar devam eder. Aşma, başlangıç ve limit değer arasından dışarı çıkmaktır. Eğer artış pozitif bir değerse, for, kontrol değişkeni limit değerden büyük olana kadar çalışır. Aksi halde, for, kontrol değişkeni limit değerden küçük olduğunda durur. Sayaç değişkeninin menzil ve aralığı boş olmamalıdır. Bu, artış'ın pozitif olması halinde, başlangıç değerinin limit değerinden küçük olması veya tam tersi olması gerektiği anlamına gelir. Daha açık olmak için, aşağıdaki oturumu örnek verebiliriz:

GS>1 -0.5 -1 {} for pstack
-1.0
-0.5
0.0
0.5
1.0
GS<5>clear 0 1 1 23 {add} for pstack
276
GS<1>

Buradaki ilk komut, hiçbirşey yapmaz, çünkü kullanmak üzere bir prosedür yoktur. Bu yüzden, sayaç değişkeninin bütün değerleri, işlenen yığınında tutulur ve bunları kullanacak bir prosedür olmamasından sebep, orada kalırlar. İkinci komut, prosedüründe iki paramatreye ihtiyaç duyan add komutunu içerir. İlk işlenen, işlenen yığınının en üstündeki elemandır ve ikinci ise döngünün sayaç değişkenidir, ve işlenen yığınına o adımda girmiştir. İkinci komut, ilk 23 pozitif sayının toplamını hesaplar. toplama işleminin çıktısı için bir başlangıç değerine ihtiyacı vardır. Bu değer de komuttan hemen önce 0 olarak verilmiştir. Başka bir deyişle, 0, for döngüsünün bir parçası değildir.

forall:(hepsi için:) Bu komut verilen dizenin her elemanı için işlem yürütür. Bu amaç için, komut, verilen dizenin her elemanını sıfırdan başlamak suretiyle numaralandırır. Döngüyü kontrol etemek için geçici bir sayaç kullanır. Geçici sayaç değişkeninin başlangıç değeri 0 olup, artım değeri 1 dir ve verilen dizenin uzunluğu kadar devam eder. Döngü yapısı for komutlarından birisi ile hemen hemen aynıdır. Tek fark, dize elemanlarının bu komutun işlemi tarafından sayaç değişkeni yerine kullanılmasıdır. Komut iki tane işlenene ihtiyaç duyar, bunlardan birincisi işlem tarafından elemanları birer birer kullanılan dizedir. İkinci işlenen işlemdir. Komutun bütün sözdizimi Array Procedure forall'dır. Aşağıdaki PostScript oturumu verilen dizenin toplamının değerlendirmesini amaçlamaktadır ve diğer bir dizenin bütün elemanlarının işlenen yığınına sevkedilmesi komutun daha sonraki açıklamaları için sunulmuştur.

GS>0 [11 23 45 -89 26 12 0 -34] {add} forall pstack
-6
GS<1>[1 22 -12 0] {} forall pstack
0
-12
22
1
-6
GS<5>

loop:(döngü:) Bu komut için sadece yürütülecek işlem olan bir işlenen girilmelidir. Çalıştırıldığı zaman, durmadan, defalarca işlemi yürütür. Diğer bir değişle, eğer işlem özel bir yapıya sahip değlise, sadece Ctrl-C gibi harici bir kesme yolu ile durdurulabilen sonsuz bir döngüdür. Eğer yürütülecek işlem exit veya stop komutlarından birisini herhangi bir yerde içeriyorsa, komutlardan birisi ile karşılaşıldığında döngü dönüşü durur ve kontrol yorumun bir sonraki nesnesine döner. Komutun sözdizimi Procedure loop şeklindedir.

Procedure or Macro Definitions

(İşlem veya Makro Tanımları)

PostScript'te Procedure veya Macro nesneler kümesinin düzenlenmesi anlamına gelir. Bu nesneler öbek sınırlayıcı çiftleri { and } içinde toplanmalıdırlar. /Macro1 {1 add 2 mul} def gibi anahtar tanımlayıcısı ile isimlendirilebilirler. Eğer yapılırsa, daha sonra anahtar /Macro ve değeri {1 add 2 mul}en üstteki element olarak, key-value çifti olarak, sözlük yığını içine yerleştirilmiş olan varolan sözlüğe eklenir. Bundan sonra, Macro1 nesnesi yorumlayıcı istemine verildiği zaman eylemi meydana gelir. Öbek içinde tanımlı olan işlem sizin isteğinize bağlı olarak karmaşık veya basit olabilir. Daha sonraki makalelerde makrolar üzerinde daha çok duracağız. Şu an için bu giriş bilgisi bizim amacımız için kâfi gelmektedir

Exercises

(Alıştırmalar)

Bu makaleden başlayarak okuyucuya bazı alıştırmalar vereceğiz. Burdaki soruların cevapları bir sonraki makalede verilecektir.

2004-11-23, generated by lfparser version 2.50

mirror server hosted at Truenetwork, Russian Federation.