9

मैं विश्वविद्यालय प्रोजेक्ट के लिए एक कंपाइलर लिख रहा हूं, और मैं अपने सार सिंटेक्स ट्री को एक नियंत्रण प्रवाह ग्राफ (सीएफजी) में बदलना चाहता हूं।औपचारिक रूप से नियंत्रण प्रवाह ग्राफ

मुझे लगता है कि सीएफजी में नोड्स (V) एएसटी से नोड्स होना चाहिए। मैं एल्गोरिदम रूप से पता बढ़त सेट (G=(V,E)) के निर्माण के लिए कैसे, लेकिन मैं एक कठिन समय प्रक्रिया में थोड़ा और अधिक औपचारिक रूप से लिखने के लिए होने

मैं इस स्केला शैली से मेल खाते पैटर्न (छद्म) बना लिया है:

def edges(n:Node)(nestedin_next: Node) : List[(Node,Node)] = 
    n match { 
     case (c_1 :: c_2::tl) => (c1,c2) :: edges(c2::tl)(nestedin_next)++ 
            edges(c_1)(c_2)//recurse 
     case c_1 :: Nil => (c_1,nestedin_next)::Nil 
     case [email protected] IF(_,c1,c2) => (i,c1)::(i,c2)::edges(c1)(nestedin_next)++ 
           edges(c2)(nestedin_next) 
     case _ => Nil 
    } 

कौन सा की तरह एक एएसटी संरचना से मेल खाना चाहिए:

(IF(1, 
     ASSIGN(x,1), // ia1 
     ASSIGN(x,2) // ia2 
    ) :: // i1 
    ASSIGN(y,2) :: // a1 
    ASSIGN(z,ADD(x,y)) :: //a2 
    IF(z, 
     RET(z), //i2r1 
     assign(z,0):: // i2a1 
     ret(z) // i2r2 
) :://i2 
    Nil 
) 

और की तरह एक edgeset प्रदान करते हैं:

{ i1 -> ia1, 
    i1 -> ia2, 
    ia1 -> a1, 
    ia2 -> a1, 
    a1 -> a2, 
    a2 -> i2, 
    i2 -> i2r1 
    i2-> i2a1 
    i2a1 -> i2r2 
    i2r2 -> _|_ 
    i2r1 -> _|_ 
} 

CFG(dot) DotSrc

किसी को भी कैसे स्केला "स्यूडोकोड" की तुलना में अधिक औपचारिक रूप से इस एक सा करने के लिए पर किसी भी संकेत मिल गया?

इम आगमनात्मक तरह कुछ सोच:

e[[ IF(_,b1,b2) ]] = (if -> b1) + (if -> b2) \cup e[[ b1 ]] \cup e[[ b2 ]] 
e[[ b1, b2 ]] = e[[b1]] \cup e[[b2]] 

(ऊपर केवल एक पेड़ और एक ग्राफ हालांकि नहीं देना होगा उदाहरण के लिए अगले बयान के तत्कालीन शाखा के किनारे से कोई बढ़त।)

संपादित करें :

मैं स्केल के लिए kiama and dataflows पर पढ़ रहा हूं, और मुझे "succ" और "निम्न" दृष्टिकोण पसंद है। फिर भी, मुझे अधिक औपचारिक वर्णन में उबालने में कठिनाई हो रही है, ज्यादातर निफ्टी childAttr, s.next की वजह से, जो कुछ औपचारिक रूप से निर्दिष्ट करने का प्रयास करते समय बदसूरत हो जाता है।

EDIT2:

मैं के माध्यम से ड्रैगन बुक और "एमएल में आधुनिक संकलक कार्यान्वयन" के रूप में अच्छी Learning to write a compiler से अन्य सामग्री में से कुछ और कुछ/सबसे उल्लेख डाटा प्रवाह और नियंत्रण प्रवाह, लेकिन कभी छूता है के रूप में किया गया है किसी भी औपचारिक तरीके से सीएफजी बनाने के तरीके पर बहुत कुछ।

EDIT3:

वाया Kiama लेखक, Associate Professor Dr. Tony Sloane मैं कुछ additional book references to look up प्राप्त।

जहां तक ​​मैं उन पुस्तकों के अनुसार "इसे करने का तरीका" देख सकता हूं, एएसटी से अधिक कार्यक्रम के "प्रति कथन" पर आधारित है और मूल ब्लॉक्स पर आधारित है। फिर भी महान इनपुट!

+0

मुझे आशा है कि आपको कोई फर्क नहीं पड़ता कि मैंने टैग में "स्कैला" जोड़ा है। –

+0

@ रैंडल बिल्कुल नहीं :) मैंने लगभग इतना किया है कि मेरा स्वयं – svrist

उत्तर

3

यदि आपका इरादा कुछ ऐसा औपचारिक रूप से बनाना है जो थोड़ा अधिक औपचारिक दिखता है, तो आप standard notation का उपयोग करके इन मिलान परिचालनों को अनुमान नियमों के रूप में व्यक्त कर सकते हैं। आपको इसे रिकर्सली के बजाए कमी के एक चरण के संदर्भ में व्यक्त करना चाहिए, क्योंकि तब तक इन नियमों को लागू करने के लिए पर्याप्त नहीं है जब तक कि और लागू नहीं किया जा सके।

उस ने कहा, यह परिभाषा अनिवार्य रूप से आपके स्कैला कोड के समान ही कहने जा रही है।क्या तुम सच में कुछ भी "औपचारिक" करना चाहते हैं तो गुण आप को साबित करने की जरूरत है:

  • आपका CFG अनुवाद एल्गोरिथ्म हमेशा समाप्त हो जाता है
  • क्या आपके CFG एक दिया एएसटी इनपुट
  • चाहे वहाँ के संबंध में कम से कम है एक दिए गए एएसटी इनपुट के लिए आपके एल्गोरिदम द्वारा व्युत्पन्न एक अद्वितीय सीएफजी है (यानी यह गैर-निर्धारिती नहीं है जो सीएफजी उत्पन्न करता है)।

मुझे नहीं लगता कि आपके बुनियादी ब्लॉक दृष्टिकोण (प्रति-कथन दृष्टिकोण के बजाए) आवश्यक रूप से एक बुरा विचार है। यह पूरी तरह से उचित लगता है कि यदि आप मूल ब्लॉक से मेल खा सकते हैं, तो आप एक नियम लिख सकते हैं जो इस मैच की उपस्थिति के आधार पर सेट सदस्यता के बारे में दावा करता है। ऐसा लगता है कि स्केचिंग शुरू करने वाली अपरिवर्तनीय परिभाषा ठीक काम कर सकती है।

कुछ और रोचक हो सकता है (औपचारिक रूप से) structured operational semantics और सीएफजी के निर्माण से संबंधित कुछ और दिलचस्प हो सकता है। इस क्षेत्र में पहले से ही काम हो सकता है, लेकिन मैंने केवल एक सरसरी Google खोज की है और दोनों के बीच कोई स्पष्ट रूप से उल्लिखित संबंध नहीं मिला है, लेकिन सहजता से ऐसा लगता है कि किसी के अस्तित्व में होना चाहिए।

+0

बहुत अच्छा इनपुट! परिचालन अर्थशास्त्र (और अनुमान नियम) के संबंध में, वे मेरे दिमाग में बहुत हाल ही में रहे हैं, इसलिए यह दिलचस्प है कि आप इसका जिक्र करते हैं। – svrist

4

Google's Closure CompilerControl-Flow Analysis लागू करता है जो जावास्क्रिप्ट के लिए एक नियंत्रण-प्रवाह ग्राफ में एएसटी को बदलता है। इस कार्यान्वयन के लिए विचार पेपर से प्रेरित हैं: Declarative Intraprocedural Flow Analysis of Java Source Code

+0

आह! Kiama JastAdd आधारित है, और यह पेपर JastAdd का उपयोग करता है। कीमा के डेटाफ्लो उदाहरण पेपर में उपयोग किए गए दृष्टिकोण से बहुत अधिक दिखते हैं। धन्यवाद – svrist