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

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



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

एल्गोरिथ्म

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

हम प्रत्येक चरित्र को बदले में मानते हैं:

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