एटी एंड टी वाक्य रचना के साथ पोलिश रिवर्स असेंबली भाषा

यह कार्यक्रम मूल रूप से मशीन-उन्मुख प्रोग्रामिंग प्रोग्रामिंग के पाठ्यक्रम पर एक छोटे प्रयोगशाला कार्य के रूप में लिखा गया था, लेकिन बाद में इसे समुदाय में पेश करने का विचार था। सटीक रूप से क्योंकि एल्गोरिथ्म इंटेल सिंटैक्स के साथ असेंबलर भाषा में लागू नहीं किया गया है, लेकिन एटी एंड टी सिंटैक्स के साथ असेंबली भाषा में।

यह वाक्यविन्यास केवल इसलिए चुना गया क्योंकि यह "सामान्य" कोडांतरक में प्रोग्राम लिखने की तुलना में मजेदार और थोड़ा गैर-मानक है।

एल्गोरिथ्म

तो, आइए एक अभिव्यक्ति को रिवर्स पोलिश नोटेशन में परिवर्तित करने के लिए एल्गोरिथम के विवरण के साथ शुरू करें।
हम प्रत्येक चरित्र को बदले में मानते हैं:

1. यदि यह वर्ण एक संख्या (या चर) है, तो इसे आउटपुट स्ट्रिंग में डालें।
2. यदि प्रतीक ऑपरेशन (+, -, *, /) का संकेत है, तो हम इस ऑपरेशन की प्राथमिकता की जांच करते हैं। गुणन और विभाजन के कार्यों की सर्वोच्च प्राथमिकता है (मान लें कि यह 3 है)। जोड़ और घटाव संचालन की प्राथमिकता कम होती है (2 के बराबर)। सबसे छोटी प्राथमिकता (1 के बराबर) उद्घाटन ब्रैकेट है।
   इनमें से एक वर्ण प्राप्त करने के बाद, हमें स्टैक की जांच करनी चाहिए:
   
   • a) यदि स्टैक अभी भी खाली है, या उसमें मौजूद प्रतीकों (और केवल ऑपरेशन के संकेत और उद्घाटन ब्रैकेट में हो सकता है) में वर्तमान चिह्न की प्राथमिकता से कम प्राथमिकता है, तो हम वर्तमान प्रतीक को स्टैक पर रख देते हैं।
   • बी) यदि स्टैक के शीर्ष पर स्थित चरित्र में वर्तमान चरित्र की प्राथमिकता से अधिक या उसके बराबर की प्राथमिकता है, तो हम स्टैक से आउटपुट स्ट्रिंग में पात्रों को निकालते हैं जब तक कि यह शर्त पूरी नहीं हो जाती; तब बिंदु पर जाएं)
   
   
3. यदि वर्तमान वर्ण एक प्रारंभिक ब्रैकेट है, तो इसे स्टैक पर रखें।
4. यदि वर्तमान वर्ण एक समापन ब्रैकेट है, तो हम स्टैक से आउटपुट लाइन में वर्णों को निकालते हैं जब तक कि हम स्टैक पर उद्घाटन ब्रैकेट का सामना नहीं करते हैं (यानी, 1 की प्राथमिकता वाला एक वर्ण), जिसे बस नष्ट कर दिया जाना चाहिए। समापन ब्रैकेट भी नष्ट हो गया है।
5. यदि पूरी इनपुट लाइन पार्स हो गई है, और स्टैक पर अभी भी संचालन के संकेत हैं, तो हम उन्हें स्टैक से आउटपुट लाइन तक निकालते हैं।

एक हब पर पहले से ही एक विषय था जिसमें एल्गोरिथ्म विस्तार से अपने काम के उदाहरणों के साथ समझा गया था। इसलिए, इस पद को इस पद के ढांचे में नहीं माना जाएगा।

कार्यक्रम

तो, चलिए प्रोग्राम लिखना शुरू करते हैं। इस कार्यान्वयन में, ऑपरेशन प्राथमिकताएं ऊपर वर्णित के समान हैं - गुणन और विभाजन के कार्यों में 3 के बराबर सर्वोच्च प्राथमिकता है, इसके अलावा और घटाव के संचालन में 2 के बराबर प्राथमिकता है, समापन ब्रैकेट प्राथमिकता है। संख्याएं शून्य प्राथमिकता हैं। एल्गोरिथ्म के सरल और अधिक लचीले कार्यान्वयन के लिए संख्याओं के लिए प्राथमिकता पेश की जाती है। इसके अलावा, समापन कोष्ठक के लिए, प्राथमिकता 5. यह एल्गोरिथ्म के कार्यान्वयन की सुविधा के लिए भी किया जाता है। निम्नलिखित एक फ़ंक्शन है जो इसे पारित किए गए चरित्र की प्राथमिकता निर्धारित करता है:
.text
.globl getPriotiry
# %eax
.type getPriority, @function
getPriority:
pushl %ebp
movl %esp, %ebp

movl 8(%esp), %eax

cmpl $42, %eax # *
je priority3
cmpl $47, %eax # /
je priority3
cmpl $43, %eax # +
je priority2
cmpl $45, %eax # -
je priority2
cmpl $40, %eax # (
je priority1
cmpl $41, %eax # )
je priority5

# -- 0
movl $0, %eax
jmp exit
priority3: # * and /
movl $3, %eax
jmp exit
priority2: # + and -
movl $2, %eax
jmp exit
priority1: # (
movl $1, %eax
jmp exit
priority5: # )
movl $5, %eax
jmp exit
exit:
leave
ret
.size getPriority, .-getPriority

एक बहुत ही दिलचस्प बिंदु स्टैक का कार्यान्वयन है। मैंने एल्गोरिथ्म के कार्यान्वयन और समझ को जटिल नहीं करने का फैसला किया और इसलिए स्टैक को निश्चित लंबाई की एक सरणी के रूप में प्रस्तुत किया गया है, जहां पहले तत्व स्टैक में तत्वों की संख्या संग्रहीत करता है। तो, नीचे स्टैक के साथ काम करने के लिए कार्य किए गए हैं: शून्यता के लिए स्टैक को रखें, लें, स्टैक का आकार प्राप्त करें। प्रत्येक फ़ंक्शन स्टैक पर एक पता लेता है।
#
.text
.globl stack_push
.type stack_push, @function
stack_push:
pushl %ebp
movl %esp, %ebp

# -- , --
movl 8(%ebp), %eax
cmp $50, %eax # . -- , , --
jg address
movl %eax, %edx
jmp number
address:
movzbl (%eax), %ebx
number:
movzbl 12(%ebp), %edx
movl %edx, (%eax, %ebx, 1)

#
movl 8(%ebp), %eax
addl $1, (%eax)

leave
ret
.size stack_push, .-stack_push
#-------------------------------------------------------------------
#
.text
.globl stack_pop
.type stack_pop, @function
stack_pop:
pushl %ebp
movl %esp, %ebp

#
movl 8(%ebp), %eax
subl $1, (%eax)
movzbl (%eax), %ebx

#
movzbl (%eax, %ebx, 1), %eax
# movzbl %edx, %eax

leave
ret
.size stack_pop, .-stack_pop
#-------------------------------------------------------------------
# 0 . 1
.text
.globl stack_isEmpty
.type stack_isEmpty, @function

stack_isEmpty:
pushl %ebp
mov %esp, %ebp

movl 8(%esp), %eax
movzbl (%eax), %eax
cmpl $1, %eax

movl $0, %eax
jg exit
movl $1, %eax

exit:
leave
ret
.size stack_isEmpty, .-stack_pop
#-------------------------------------------------------------------
#
.text
.globl stack_size
.type stack_size, @function

stack_size:
pushl %ebp
movl %esp, %ebp

movl 8(%esp), %eax
movzbl (%eax), %eax
subl $1, %eax

leave
ret
.size stack_size, .-stack_size
#-------------------------------------------------------------------
#
.text
.globl stack_top
.type stack_top, @function

stack_top:
pushl %ebp
movl %esp, %ebp

movl 8(%esp), %eax
movzbl (%eax), %ebx
subl $1, %ebx
movzbl (%eax, %ebx, 1), %eax

leave
ret
.size stack_top, .-stack_size

एल्गोरिथ्म का मुख्य चक्र इस प्रकार है:

1. स्ट्रिंग का अगला तत्व लें
2. चरित्र को प्राथमिकता दें
3. ऑपरेशन के आधार पर, आवश्यक कार्रवाई करें: इसे स्टैक पर धकेलें, परिणामी लाइन में धकेलें, या स्टैक से सभी ऑपरेशन को ब्रैकेट में धकेल दें।

कार्यक्रम का यह हिस्सा काफी सीधा और निर्बाध है, इसलिए इसे लाने का कोई मतलब नहीं है।
पूरा प्रोग्राम कोड और साथ ही मेकफाइल यहां पाया जा सकता है: dl.dropbox.com/u/1379084/4.pip