😅 🈷️ 🎇 वसा ढूँढना (वसा के लिए क्वेस्ट) 🙎🏿 💸 🎫

एक निश्चित हार्डवेयर और सॉफ्टवेयर कॉम्प्लेक्स को विकसित करते समय, एक क्लाइंट डिवाइस बनाना आवश्यक था, जो अन्य उपकरणों के लिए एक नियमित यूएसबी फ्लैश ड्राइव की तरह दिखना चाहिए, या, अधिक औपचारिक रूप से, एक यूएसबी मास स्टोरेज डिवाइस। यह उपकरण असामान्य है कि यह बाहरी दुनिया के लिए पर्याप्त रूप से बड़े आकार (2GB या अधिक) की फ़ाइलों के साथ FAT फाइल सिस्टम का अनुकरण करना चाहिए, इस तथ्य के बावजूद कि डिवाइस पर फ़ाइलें स्वयं, अनुपस्थित हैं और नेटवर्क पर हैं। वैसे भी, ये फाइलें नहीं हैं, लेकिन कुछ प्रकार की ऑडियो स्ट्रीम हैं।

कार्य, पहली नज़र में, सरल है: प्रत्येक ब्लॉक (SCSI कमांड) को पढ़ने के अनुरोध के लिए हम इस ब्लॉक की सामग्री देते हैं। एक ब्लॉक या तो किसी भी "फाइल" से संबंधित हो सकता है या उसमें FAT ओवरहेड जानकारी हो सकती है।

पहला विचार, निश्चित रूप से, FAT छवि को पैक करने के लिए था, उदाहरण के लिए, bzip2 और इसे आवश्यकतानुसार डिवाइस पर अनपैक करें। तीन समस्याएं तुरंत उत्पन्न होती हैं:

100 मेगाबाइट फ़ाइलों और कई निर्देशिकाओं की एड़ी से फ़ाइल सिस्टम की एक संकुचित छवि 125Kb के आसपास कुछ लेती है, जो डिवाइस पर रैम की मात्रा से अधिक है।
Bzip2, जाहिरा तौर पर, क्षेत्रों के बारे में कुछ भी नहीं जानता है और प्रवाह के स्तर पर काम करता है, इसलिए, सेक्टर-दर-सेक्टर को पैक करना आवश्यक होगा, इसलिए छवि का आकार बिल्कुल अपमानजनक होगा: जैसा कि आप जानते हैं, छोटे ब्लॉकों के साथ पैकिंग करना लाभहीन है - संपीड़न से लाभ की तुलना में ओवरहेड बड़ा है।
छवि तैयार करना (एक खाली फ़ाइल को बढ़ाना, एक फ़ाइल सिस्टम बनाना, पैकिंग करना) में बहुत समय लगता है और सर्वर पर कार्यान्वयन के लिए शायद ही स्वीकार्य होता है जिसमें अनुमानित हजारों उपयोगकर्ता होते हैं। और निर्माण की प्रक्रिया में छवि को कुछ काफी ध्यान देने योग्य डिस्क स्थान की आवश्यकता होती है।

इस तथ्य का उल्लेख नहीं करना है कि आपको माइक्रोकंट्रोलर के लिए bzip2 को पोर्ट करना है।

इसलिए कुछ और ऊपर आना पड़ा।

समस्या को निम्न प्रकार से प्रस्तुत किया जा सकता है: एक कोड लिखना आवश्यक है जो फ़ाइल सिस्टम के कुछ विवरण को किसी न किसी रूप में इनपुट के रूप में लेगा, और सेक्टर नंबर के प्रत्येक अनुरोध के लिए इसकी सामग्री वापस करेगा। सामग्री या तो सेवा की जानकारी या फ़ाइल डेटा है, जो किसी दिए गए URL पर संबंधित ऑडियो स्ट्रीम से लिए गए हैं।

प्रश्न का यह सूत्रीकरण हमें नियमों की एक प्रणाली की ओर ले जाता है:

=>

ध्यान दें कि हम सेक्टरों के बारे में बात कर रहे हैं, न कि "क्लस्टर", क्योंकि क्लस्टर एक एफएटी फाइल सिस्टम की अवधारणा है। डिवाइस ब्लॉक स्तर पर काम करते हैं, वे भी सेक्टर हैं। मान लीजिए कि हमारी "प्लेलिस्ट" में 2Gb की 10 "फाइलें" हैं (2Gb अनंत के लिए ऐसा व्यावहारिक दृष्टिकोण है)। यदि प्रत्येक नियम में एक बाइट का आकार होता है, जो निश्चित रूप से असंभव है, तो हम इसे प्राप्त करते हैं।

2*1024*1024*1024 * 10 / 512 = 41 943 040

सभी नियमों के लिए बाइट। कुछ हद तक अधिक उचित है। लेकिन, निश्चित रूप से, नियम प्रत्येक क्षेत्र के लिए अद्वितीय नहीं हैं। हम सेक्टरों की श्रेणियों के लिए नियम निर्धारित करेंगे। यह हमें नियमों के एक समूह की ओर ले जाता है:

(A) =>
(A,B) =>

हम स्वयं सेक्टरों को पैक करने का भी प्रयास करेंगे। चूंकि हमें डेटा को संपीड़ित करने के कार्य से सामना नहीं किया जाता है - डेटा स्वयं डिवाइस में उपलब्ध नहीं है और वेब से लिया गया है, आपको बस किसी तरह फ़ाइल सिस्टम के सेवा डेटा की अधिक या कम कॉम्पैक्ट प्रस्तुति प्रदान करने की आवश्यकता है। पहली नज़र में, इस डेटा में कई दोहराए जाने वाले अनुक्रम हैं, इसलिए हम निम्नानुसार कोड करेंगे: दोहराए गए अनुक्रमों के रूप में प्रतिनिधित्व किया जाता है

( RLE, , )

के रूप में गैर दोहराव दृश्यों का प्रतिनिधित्व करते हैं

( Sequence, )

इसके अलावा, उन अनुक्रमों को जिन्हें हम पहले ही एन्कोड कर चुके हैं, या उनमें से कुछ हिस्सों को फिर से सम्मिलित नहीं करना अच्छा होगा, लेकिन उन्हें देखें। हमारे पास शायद एक और अनुक्रम है

( , )

शायद कार्यान्वयन प्रक्रिया के दौरान, फ़ाइल सिस्टम संरचनाओं के अधिक कॉम्पैक्ट प्रतिनिधित्व के लिए अन्य अनुक्रम दिखाई दे सकते हैं।

यह सब एक वर्चुअल मशीन के कमांड सिस्टम के समान है, और चूंकि कॉल होते हैं, यानी स्टैक। सबसे सरल ज्ञात आभासी मशीन एक किले की किस्मों में से एक है। वास्तव में, यह विपरीत है।
स्टेरॉयड पर पोलिश रिकॉर्ड, कॉल से वापसी पते के एक अतिरिक्त ढेर के साथ, जो समारोह के फ्रेम को व्यवस्थित करने के साथ परेशान करने की आवश्यकता को समाप्त करता है: सब कुछ बेहद सरल है - हम इसे कॉल से लौटने पर हटा देते हैं
स्टैक आर से शीर्ष शब्द और उस पते पर जाएं जिस पर यह इंगित करता है।

इसके अलावा, दो-स्टैक मशीन के लिए टोकन थ्रेडेड कोड (और यह यह होगा) में बहुत अच्छा घनत्व है, जो इस मामले में, हमें बहुत अच्छी तरह से सूट करता है।

ऐसे कोड की व्याख्या करना तेज़ है, यह देशी कोड की तुलना में औसतन पाँच गुना धीमा है, और बहुत सरल भी है।

इसलिए, हमारे पास कुछ प्रकार की कोडिंग प्रणाली, नियमों की एक प्रणाली और कुछ प्रकार की वर्चुअल मशीन हैं, जिन पर इन नियमों को चलाया जाना चाहिए।

यह एक निश्चित विवरण से इन नियमों को उत्पन्न करने के लिए बनी हुई है, एक बाईटेकोड प्राप्त करें और इसकी व्याख्या के लिए एक मशीन लागू करें। और उसके बाद ही हम देखेंगे कि क्या हुआ।

एक वर्चुअल मशीन के कार्यान्वयन के साथ, स्थिति सरल है: यह क्रमशः एक माइक्रोकंट्रोलर पर काम करेगा, यहां अब तक कोई सी विकल्प नहीं हैं। सच है, यह संभव है कि वहाँ कुछ भी नहीं है - यह किसी भी तरह से इसे उत्पन्न करेगा
जिस तरह से।

जो कुछ भी रहता है वह विवरण, विवरण, कोड पीढ़ी और इस कोड के आदेशों के विवरण से नियम प्रणाली की पीढ़ी है। इसके अलावा, नियमों को क्रमिक रूप से नहीं, बल्कि किसी भी तरह से और अधिक तर्कसंगत रूप से जांचना अच्छा होगा: फॉर्म में चेक व्यवस्थित करें
तुलनात्मक वृक्ष, ताकि प्रति सेक्टर की तुलनाओं की संख्या तुलनाओं की संख्या के द्विआधारी लघुगणक के क्रम की होगी।

हमने प्रारंभिक विश्लेषण पूरा कर लिया है, हमें एक प्रोटोटाइप बनाना होगा और देखना होगा कि हमें क्या मिलता है।

हमें विभिन्न आयामों और एंडियनसेस (बाइनरी सेवा डेटा कम-एंडियन प्रारूप में लिखे गए हैं) के बाइनरी डेटा को उत्पन्न करने और संभवतः करने की आवश्यकता होगी, और नेस्टेड डेटा संरचनाओं के साथ काम करना होगा।

इसे किस पर लागू किया जाएगा? सी, सी ++ या शायद पायथन? या रूबी? एक चुटकुला।
बेशक, हम इसे हास्केल में करेंगे: कार्य सबसे सरल नहीं है, इसके लिए किसी प्रकार के प्रदर्शन की आवश्यकता होती है, और हमारे पास बहुत कम समय होता है। वैसे भी, इस कोड को कॉल करने वाले सर्वर को भी लागू किया जाता है
हास्केल, इसलिए पसंद काफी स्वाभाविक है।

चलिए शुरू करते हैं।

सिस्टम में केंद्रीय चीज "नियम" है। वे फ़ाइल सिस्टम के विवरण को परिवर्तित करते हैं, उनसे कोड उत्पन्न होता है। हम उनका वर्णन करते हैं:

data Rule = REQ Int [Chunk] | RANGE Int Int [Chunk] deriving Show
data Chunk = SEQ BS.ByteString
| RLE Int Word8
deriving (Eq, Ord)

इसके अलावा, फ़ाइल सिस्टम का ही विवरण है, जिसमें निर्देशिका और फाइलें शामिल हैं, जिसमें एफएटी की कुछ विशिष्टताएं हैं।

 data Entry = DirRoot Int [Entry] | DirDot Int | DirDotDot Int | Dir Int String [Entry] | File Int String Int BS.ByteString deriving (Eq, Ord, Data, Typeable, Show)

data Entry = DirRoot Int [Entry] | DirDot Int | DirDotDot Int | Dir Int String [Entry] | File Int String Int BS.ByteString deriving (Eq, Ord, Data, Typeable, Show)

यहाँ हम और अधिक विस्तार से रहते हैं। अजीब कंस्ट्रक्टर डिडोर और डिअरडॉटडॉट '' 'निर्देशिकाएँ से ज्यादा कुछ नहीं हैं और '..', जो - यहाँ एक आश्चर्य है - शीर्ष पर हैं, शारीरिक रूप से वर्तमान निर्देशिका प्रविष्टियाँ। सौभाग्य से वे
केवल लिंक हैं और समूहों के आवंटन की आवश्यकता नहीं है।

अन्यथा, सब कुछ बहुत स्पष्ट है: प्रकार के निर्माणकर्ताओं की पहली विशेषता एक अद्वितीय पहचानकर्ता है। यह स्पष्ट रूप से फर्मवेयर को समझने के लिए हमारे लिए उपयोगी हो सकता है जिसमें से डेटा "फ़ाइल" का अनुरोध किया गया था।

दूसरी विशेषता फ़ाइल नाम है। किसी फ़ाइल के मामले में, हम उसका आकार और डेटा भी जोड़ते हैं। यह, ज़ाहिर है, फ़ाइल का डेटा ही नहीं है, लेकिन डिवाइस के फर्मवेयर के कुछ संकेत हैं जहां यह डेटा प्राप्त करना है। वहाँ आप लिख सकते हैं, उदाहरण के लिए, एक sshsh संरचना या स्ट्रीम URL। इसलिए बाइटस्ट्रीमिंग।

अब हमें किसी तरह से फाइल सिस्टम की आवश्यकताओं को ध्यान में रखते हुए एंट्री का निर्माण करने की आवश्यकता है: प्रत्येक निर्देशिका, रूट को छोड़कर, प्रविष्टियों को दर्ज करना होगा। '' और '..', उन्हें संबंधित निर्देशिकाओं का उल्लेख करना चाहिए, नहीं होना चाहिए
समान रिकॉर्ड नाम, नामों में निषिद्ध वर्ण और इतने पर और आगे नहीं होना चाहिए। यह देखा जा सकता है कि मैन्युअल रूप से इस संरचना को बनाना मुश्किल है, इसके अलावा, एपीआई के उपयोगकर्ता को इससे निपटना होगा, और वह निश्चित रूप से कुछ मिलाएगा और सब कुछ टूट जाएगा, लेकिन यह एक गंभीर मामला है। इसलिए हमारे मॉड्यूल से एंट्री-प्रकार की सामग्री के आयात को रोकना बेहतर है, और उपयोगकर्ता को कुछ अधिक सुविधाजनक और त्रुटि-सुरक्षित समाधान प्रदान करता है। कुछ इस तरह:

 fileContents = ... fatSample2 = filesystem $ do file "file0" (16384) fileContents dir "A" $ do file "file1" (megs 100) fileContents dir "C" $ do file "file3" (megs 100) fileContents file "file4" (megs 100) fileContents file "file5" (megs 100) fileContents dir "E" $ emptyDir dir "B" $ do file "file2" (megs 50) emptyFile

fileContents = ... fatSample2 = filesystem $ do file "file0" (16384) fileContents dir "A" $ do file "file1" (megs 100) fileContents dir "C" $ do file "file3" (megs 100) fileContents file "file4" (megs 100) fileContents file "file5" (megs 100) fileContents dir "E" $ emptyDir dir "B" $ do file "file2" (megs 50) emptyFile

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

इसके अलावा, हमें विशिष्ट पहचानकर्ताओं को वितरित करने की आवश्यकता होगी, इसलिए राज्य भी उपयोगी है, जहां हम किसी प्रकार का काउंटर लगाते हैं। चूंकि हम स्टेट और राइटर को पार करना चाहते हैं, इसलिए मोनड ट्रांसफार्मर हमें नुकसान नहीं पहुंचाएगा। कुछ इस तरह:

 newtype EntryIdT ma = EntryIdT { runF :: (WriterT [Entry] (StateT (Int, Int) m)) a } deriving (Monad, MonadWriter [Entry], MonadState (Int, Int)) type EntryIdM = EntryIdT Identity runEntryIdM :: (Int, Int) -> EntryIdM a -> ([Entry], (Int, Int)) runEntryIdM init f = runState (execWriterT (runF f)) init filesystem :: EntryIdM () -> Entry filesystem f = DirRoot 0 dirs where dirs = fst $ runEntryIdM (1,0) f dir :: String -> EntryIdM () -> EntryIdM () file :: String -> Int -> (EntryInfo -> BS.ByteString) -> EntryIdM ()

newtype EntryIdT ma = EntryIdT { runF :: (WriterT [Entry] (StateT (Int, Int) m)) a } deriving (Monad, MonadWriter [Entry], MonadState (Int, Int)) type EntryIdM = EntryIdT Identity runEntryIdM :: (Int, Int) -> EntryIdM a -> ([Entry], (Int, Int)) runEntryIdM init f = runState (execWriterT (runF f)) init filesystem :: EntryIdM () -> Entry filesystem f = DirRoot 0 dirs where dirs = fst $ runEntryIdM (1,0) f dir :: String -> EntryIdM () -> EntryIdM () file :: String -> Int -> (EntryInfo -> BS.ByteString) -> EntryIdM ()

प्रत्येक फ़ंक्शन नेस्टेड रिकॉर्ड बनाने के लिए नाम, आकार और एक अन्य मानद मान जैसे पैरामीटर लेता है। प्रत्येक ऐसी गणना एक अलग लेखक में चलाई जाएगी, और यह सुनिश्चित करने के लिए राज्य को घसीटा जाएगा कि पहचानकर्ता अद्वितीय हैं।

इसलिए, हमने निर्देशिका संरचना निर्धारित की है, अब हमें किसी भी तरह से नियमों को प्राप्त करने की आवश्यकता है।

ऐसा करने के लिए, किसी तरह डेटा फ़ाइलों और निर्देशिकाओं को "डिस्क" पर रखें।
हम मानते हैं कि उन्हें क्रमिक रूप से, पहले निर्देशिकाओं, फिर फाइलों में रखा गया है:

 data AllocEntry = AllocEntry { beginSect :: Int , endSect :: Int , entry :: Entry } deriving (Show) allocate :: ClustSize32 -> Int -> Entry -> [AllocEntry] allocate cl from = eFix . eAlloc . eOrder . filter eFilt . universe where eFilt (File _ _ _ _) = True eFilt (Dir _ _ _) = True eFilt (DirRoot _ _) = True eFilt _ = False eOrder = uncurry (++) . partition (not.isFile) eAlloc = reverse . snd . foldl fentry (from, []) fentry (n, xs) e = let sectors = entryLen cl e `div` fatSectLen begin = n end = begin + sectors - 1 n' = n + sectors allocated = AllocEntry begin end e in (n', allocated : xs) eFix = id

data AllocEntry = AllocEntry { beginSect :: Int , endSect :: Int , entry :: Entry } deriving (Show) allocate :: ClustSize32 -> Int -> Entry -> [AllocEntry] allocate cl from = eFix . eAlloc . eOrder . filter eFilt . universe where eFilt (File _ _ _ _) = True eFilt (Dir _ _ _) = True eFilt (DirRoot _ _) = True eFilt _ = False eOrder = uncurry (++) . partition (not.isFile) eAlloc = reverse . snd . foldl fentry (from, []) fentry (n, xs) e = let sectors = entryLen cl e `div` fatSectLen begin = n end = begin + sectors - 1 n' = n + sectors allocated = AllocEntry begin end e in (n', allocated : xs) eFix = id

एक पूरे के रूप में कोड काफी स्पष्ट है: हम सभी रिकॉर्ड लेते हैं, 'हटाएं'। और '..' जिनके पास अपने स्वयं के क्लस्टर नहीं हैं, लेकिन केवल अजनबियों को इंगित करते हैं, हम निर्देशिकाओं को पहले बनाते हैं, फिर फाइलें (कोई अंतर नहीं है, लेकिन यह अधिक तार्किक है,)
और वॉल्यूम की सामग्री पढ़ने के लिए तेज़ हो जाएगी), हम क्षेत्रों का चयन करते हैं (यह हमारे लिए क्षेत्रों के साथ काम करने के लिए अधिक सुविधाजनक है, "क्लस्टर" एक कृत्रिम अवधारणा है) और वह सब है।

यह यूनिलेट मॉड्यूल से ब्रह्मांड फ़ंक्शन को ध्यान देने योग्य है। यह आपको एक सूची में नेस्टेड संरचना के सभी तत्वों को सूचीबद्ध करने की अनुमति देता है (यदि वांछित, सूची समझ के साथ) पुनरावर्ती ट्रैवर्सल कार्यों के नियमित लेखन से बचने के लिए।

यह उसकी खातिर है कि हमने ऊपर एंट्री व्युत्पन्न (डेटा, टाइप करने योग्य) प्रकार की घोषणा की।

सेक्टरों द्वारा रखी गई फाइलें होने से, उनके लिए नियम बनाने के लिए हमें कुछ भी खर्च नहीं करना पड़ता है:

 generateData :: Maybe CalendarTime -> ClustSize32 -> [AllocEntry] -> [Rule] generateData ct cl es = mergeRules $ execWriter $ do forM_ es $ \(AllocEntry {beginSect = a, endSect = b, entry = e}) -> do case e of DirRoot _ es -> writeEntries ab es Dir _ _ es -> writeEntries ab es File _ _ _ bs -> tell [RANGE ab (encodeBlock (BS.take (fatSectLen) bs))] where ...

generateData :: Maybe CalendarTime -> ClustSize32 -> [AllocEntry] -> [Rule] generateData ct cl es = mergeRules $ execWriter $ do forM_ es $ \(AllocEntry {beginSect = a, endSect = b, entry = e}) -> do case e of DirRoot _ es -> writeEntries ab es Dir _ _ es -> writeEntries ab es File _ _ _ bs -> tell [RANGE ab (encodeBlock (BS.take (fatSectLen) bs))] where ...

एन्कोडब्लॉक फ़ंक्शन यहाँ नियमों के अनुक्रम में एक बाइटस्ट्रिंग को एनकोड कर सकता है, राइटएन्ट्री डायरेक्टरी प्रविष्टियाँ उत्पन्न करता है और उन्हें एनकोड करता है, और मर्जर्यूलर क्रमिक नियमों के क्षेत्रों की सीमा को संयोजित करने का प्रयास करता है।

एकल निर्देशिका प्रविष्टि बनाना कुछ इस तरह दिखता है:

 entryRecordShort :: String -> Int -> Int -> Maybe CalendarTime -> [ATTR] -> BS.ByteString entryRecordShort nm size clust clk a = runPut $ do putNameASCII nm -- Name putWord8 (fatAttrB a) -- Attr putWord8 0 -- NTRes putWord8 0 -- CrtTimeTenth putWord16le cT -- CrtTime putWord16le cD -- CrtDate putWord16le cD -- LstAccDate putWord16le cHi -- FstClusHI putWord16le cT -- WrtTime putWord16le cD -- WrdDate putWord16le cLo -- FstClusLO putWord32le (fromIntegral size) -- FileSize where ...

entryRecordShort :: String -> Int -> Int -> Maybe CalendarTime -> [ATTR] -> BS.ByteString entryRecordShort nm size clust clk a = runPut $ do putNameASCII nm -- Name putWord8 (fatAttrB a) -- Attr putWord8 0 -- NTRes putWord8 0 -- CrtTimeTenth putWord16le cT -- CrtTime putWord16le cD -- CrtDate putWord16le cD -- LstAccDate putWord16le cHi -- FstClusHI putWord16le cT -- WrtTime putWord16le cD -- WrdDate putWord16le cLo -- FstClusLO putWord32le (fromIntegral size) -- FileSize where ...

यहां हम Data.Binary.Put से असाधारण रूप से उपयोगी PutM monad का उपयोग करते हैं, जो आपको किसी आलसी बाइट स्ट्रिंग के लिए किसी भी बिट डेप्थ और एंडियनिटी का डेटा आउटपुट करने की अनुमति देता है।

इसलिए, हमारे पास एफएटी वॉल्यूम की निर्देशिका संरचना है, हमारे पास सेक्टर और संबंधित नियमों द्वारा उनका आवंटन है। हमारे पास क्या बचा है?

यहां आपको थोड़ा पीछे हटने और FAT डिवाइस को याद रखने की आवश्यकता है। यदि आप अनावश्यक विवरणों में नहीं जाते हैं जो वेब पर और साहित्य में व्यापक रूप से उपलब्ध हैं, तो FAT32 इस तरह से डिज़ाइन किया गया है:

     | बूटसेक्ट | FAT32 जानकारी | FAT1 | FAT2 | DATA |

अब तक, हमारे पास केवल डेटा के लिए नियम हैं। FAT1 और FAT2 क्लस्टर आवंटन तालिकाएँ हैं। प्रत्येक फ़ाइल या निर्देशिका (जो एक फ़ाइल भी है) डेटा क्षेत्र में क्लस्टर की एक श्रृंखला पर कब्जा कर लेती है, और डेटा क्षेत्र के प्रत्येक क्लस्टर को FAT1 और FAT2 (वे समान हैं) में 32-बिट मान द्वारा दर्शाया गया है।

प्रत्येक FAT सेल में फ़ाइल के अगले क्लस्टर की संख्या होती है, अंतिम क्लस्टर को एक विशेष मूल्य के साथ चिह्नित किया जाता है। निर्देशिका प्रविष्टि में फ़ाइल के पहले क्लस्टर की संख्या इंगित की गई है। हमारे पास जो डेटा है वह क्रमिक रूप से रखा गया है, ताकि श्रृंखला के प्रत्येक सेल में नंबर N + 1 लिखा जाए, जहां N पिछला मान है।

यहां पहली समस्या उत्पन्न होती है: हमारी गणना की गई 10 x 20Gb के लिए, यह तालिका 655360 32-बिट मानों पर कब्जा करेगी, जो फिर से उपलब्ध रैम से अधिक है। हालाँकि, इन नियमों को संपीड़ित नहीं किया जा सकता है।
हमारे आदिम RLE पैकिंग एल्गोरिथ्म, क्योंकि कोई डुप्लिकेट मान नहीं हैं। हालाँकि, चूंकि हम इस अनुक्रम को एक बार जनरेट करने में सक्षम थे, हम शायद इसे फिर से, पहले से ही डिवाइस पर जनरेट कर पाएंगे।

एक नज़दीकी नज़र ने दिखाया कि आवंटन तालिका के एक क्षेत्र में मूल्य पिछले एक में अधिकतम मूल्य पर निर्भर करता है, और सामान्य तौर पर, अनुक्रम अभिव्यक्ति द्वारा निर्धारित किया जाता है:

     ना = बेस + (सस्टेक्ट - एम) * स्टेप
     नी <- [ना, ना + १ ..]

जहाँ Na इस क्षेत्र के लिए पहला मूल्य है, सस्टेक्ट अनुरोधित क्षेत्र की संख्या है (यह हमारे किले मशीन के ढेर के ऊपर होगा), M, BASE और STEP स्थिर रूप से गणना की गई स्थिरांक हैं, Ni अनुक्रम की i-th संख्या है, और कुल मिलाकर इस क्षेत्र में। जाहिर है 512/4।

इस प्रकार, हमने एक नया अनुक्रम प्राप्त किया है जो गतिशील डेटा (क्षेत्र संख्या) के आधार पर मूल्यों की एक श्रृंखला उत्पन्न करता है। इस क्रम और आसन्न लोगों के लिए प्रकार जोड़ें:

 data Chunk = SEQ BS.ByteString | RLE Int Word8 | SER Word32 Word32 | NSER Word32 Int Word32 -- base offset step | CALLBACK Word8 deriving (Eq, Ord)

data Chunk = SEQ BS.ByteString | RLE Int Word8 | SER Word32 Word32 | NSER Word32 Int Word32 -- base offset step | CALLBACK Word8 deriving (Eq, Ord)

आगे देखते हुए, हम कॉलबैक के लिए एक और नियम जोड़ते हैं, जिसे फ़ाइल डेटा क्षेत्र की पीढ़ी के बाद कॉल किया जाना चाहिए, ताकि डिवाइस फर्मवेयर एक बफर ले और इसे वास्तविक डेटा से भर दे।

नियमों के एक सेट के रूप में तुरंत एक तालिका उत्पन्न करना संभव होगा, लेकिन किसी कारण के लिए मुझे द्विआधारी रूप में इसकी आवश्यकता थी, इसके अलावा, बाइनरी स्ट्रिंग्स को एन्कोडिंग के लिए पहले से ही डीबग किया गया कार्य है, और प्रत्यक्ष पीढ़ी में यह आसान है
गलतियाँ करना।

यह तालिका काफी बड़ी है, और एक बड़े डेटा क्षेत्र और एक छोटे क्लस्टर आकार के मामले में, गरीब हास्केल के पास एक कठिन समय है।

कुछ बिंदु पर, एक बड़ी आलसी Word32 सूची से, एप्लिकेशन को वास्तव में बुरा लगा, इसलिए मुझे जल्दी से इसे आलसी बाइट-लाइनों के लिए फिर से लिखना पड़ा और 32-बिट मानों को वहां लगाने और उन्हें पुनः प्राप्त करने के लिए runPut / runGet का उपयोग करना पड़ा।

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

हम तालिका के पीढ़ी के कार्यों और इसके लिए नियमों को छोड़ देते हैं, वे काफी बड़े हैं, लेकिन एक ही समय में काफी स्पष्ट हैं:

 type ClusterTable = BS.ByteString genFAT :: ClustSize32 -> Int -> [AllocEntry] -> ClusterTable encodeFAT :: Int -> ClusterTable -> [Rule]

type ClusterTable = BS.ByteString genFAT :: ClustSize32 -> Int -> [AllocEntry] -> ClusterTable encodeFAT :: Int -> ClusterTable -> [Rule]

तालिका एन्कोडिंग फ़ंक्शन पहले प्रत्येक सेक्टर को एक नियम REQ a (NSER _ _ _) के साथ जोड़ता है, फिर जोड़े में सेक्टर पर विचार करता है और यदि दो सेक्टर मानों का एक सामान्य अनुक्रम बनाते हैं, तो सेक्टर के लिए नियम को सेक्टरों की श्रेणी के लिए नियम से बदल दिया जाता है, जिसके परिणाम काफी कॉम्पैक्ट होते हैं ताकि आप इसे यहां ला सकें:

 REQ 32 [SEQ [F8], RLE 2 255, SEQ [0F], RLE 3 255, SEQ [0F],
         RLE 3 255, SEQ [0F], RLE 3 255, SEQ [0F], RLE 3 255,
         SEQ [0F], RLE 3 255, SEQ [0F], RLE 3 255, SEQ [0F],
         SEQ [08], RLE 3 0, SEQ [09], RLE 3 0, SEQ [0A],
         RLE 3 0, RLE 3 255, SEQ [0F], SER 12 128]
 रेंज 33,231 [एनएसईआर 129 33 128]
 REQ 232 [SER 25601 25610, RLE 3 255, SEQ [0F], SER 25612 25728]
 रेंज 233 431 [एनएसईआर 25729 233 128]
 REQ 432 [SER 51201 51210, RLE 3 255, SEQ [0F], SER 51212 51328]
 रेंज 433 631 [NSER 51329 433 128]
 REQ 632 [SER 76801 76810, RLE 3 255, SEQ [0F], SER 76812 76928]
 रेंज 633 831 [एनएसईआर 76929 633 128]
 REQ 832 [SER 102401 102410, RLE 3 255, SEQ [0F], SER 102412 102528]
 RANGE 833 931 [NSER 102529 833 128]
 REQ 932 [SER 115201 115210, RLE 3 255, SEQ [0F], RLE 468 0]
 Range 933 1056 [RLE 512 0]

यह एक दो मेगाबाइट डेटा की तुलना में स्पष्ट रूप से बेहतर लग रहा है।
तालिका की दूसरी प्रतिलिपि स्थिरांक के लिए सटीक है, इसलिए भविष्य में आप इस क्रम को ऑफसेट से निरंतर घटाकर और पहली तालिका को कॉल करके बदल सकते हैं। लेकिन वह बाद में।

तो, हमारे पास FAT1, FAT2 और DATA हैं। यह केवल BootSect और FAT32 जानकारी प्राप्त करने के लिए बना हुआ है। यह स्थैतिक बाइनरी डेटा है, इसलिए हम फिर से Data.Binary.Put का उपयोग करते हैं, और फिर हम इसे नियमों में पैक करते हैं।

ये दो मॉड्यूल (पुट और गेट) शाब्दिक रूप से अपरिहार्य हैं और व्यक्तिगत रूप से मैं उन्हें अर्लंग में द्विआधारी पैटर्न की तुलना में अधिक बोली देता हूं, हालांकि यह व्यक्तिपरक है।

 fatGenBoot32 :: FAT32GenInfo -> BS.ByteString fatGenBoot32 info = addRsvd $ runPut $ do -- BOOT AREA sect0 putBytes [0xEB, 0x58, 0x90] -- 0 JmpBoot putBytes bsOEMName -- OEMName putWord16le bps -- BytesPerSec putWord8 spc -- SectPerClust putWord16le rsvd -- ReservedSecCnt putWord8 2 -- NumFATs putWord16le 0 -- RootEntCnt putWord16le 0 -- TotSec16 putWord8 0xF8 -- Media putWord16le 0 -- FAT16Sz putWord16le 0x3F -- SectPerTract putWord16le 0xFF -- NumHeads putWord32le 0 -- HiddSec putWord32le sectNum -- TotSec32 -- FAT32 Structure putWord32le fsect -- FATSz32 -- ... --

fatGenBoot32 :: FAT32GenInfo -> BS.ByteString fatGenBoot32 info = addRsvd $ runPut $ do -- BOOT AREA sect0 putBytes [0xEB, 0x58, 0x90] -- 0 JmpBoot putBytes bsOEMName -- OEMName putWord16le bps -- BytesPerSec putWord8 spc -- SectPerClust putWord16le rsvd -- ReservedSecCnt putWord8 2 -- NumFATs putWord16le 0 -- RootEntCnt putWord16le 0 -- TotSec16 putWord8 0xF8 -- Media putWord16le 0 -- FAT16Sz putWord16le 0x3F -- SectPerTract putWord16le 0xFF -- NumHeads putWord32le 0 -- HiddSec putWord32le sectNum -- TotSec32 -- FAT32 Structure putWord32le fsect -- FATSz32 -- ... --

हम अपने पैकर को परिणाम पर डालते हैं, नियमों को श्रेणियों में विलय करते हैं, और नियमों की अंतिम सूची प्राप्त करते हैं जो हमारी पूरी फाइल प्रणाली का वर्णन करता है।

इसलिए, हमारे पास नियमों का एक सेट है। यह उनके लिए एक तुलना वृक्ष उत्पन्न करने के लिए बना हुआ है और
यह सब बायटेकोड में संकलित करें।

आइए पेड़ से शुरू करें:

 data CmpTree = GEQ Int CmpTree CmpTree | CODE [Rule] deriving (Show) mkCmpTree :: [Rule] -> CmpTree mkCmpTree r = mkTree' rulemap where rulemap = M.fromList $ map (\x -> (fsect x, x)) r splitGeq nm = let (a, b, c) = M.splitLookup nm in (a, c `M.union` (maybe M.empty (M.singleton n) b)) mkTree' xs | M.null xs = CODE [] | M.size xs < 3 = CODE (map snd (M.toList xs)) | otherwise = let ks = map fst $ M.toAscList xs n = ks !! (length ks `div` 2) (le, geq) = splitGeq n xs in GEQ n (mkTree' le) (mkTree' geq)

data CmpTree = GEQ Int CmpTree CmpTree | CODE [Rule] deriving (Show) mkCmpTree :: [Rule] -> CmpTree mkCmpTree r = mkTree' rulemap where rulemap = M.fromList $ map (\x -> (fsect x, x)) r splitGeq nm = let (a, b, c) = M.splitLookup nm in (a, c `M.union` (maybe M.empty (M.singleton n) b)) mkTree' xs | M.null xs = CODE [] | M.size xs < 3 = CODE (map snd (M.toList xs)) | otherwise = let ks = map fst $ M.toAscList xs n = ks !! (length ks `div` 2) (le, geq) = splitGeq n xs in GEQ n (mkTree' le) (mkTree' geq)

यह सबसे अच्छा विकल्प नहीं हो सकता है, लेकिन नियम सौ से कम हो गए हैं, आप अभी तक चिंता नहीं कर सकते।

यह वर्चुअल मशीन, कमांड के सेट और कंपाइलर पर निर्भर है:

 -  ,     -     class OpcodeCL a where isRLE :: a -> Bool arity0 :: a -> Bool arity1 :: a -> Bool arity2 :: a -> Bool arity3 :: a -> Bool firstCode :: a lastCode :: a data Opcode = DUP | DROP | CONST | CRNG | JNZ | JZ | JGQ | JNE | JMP | CALLT | CALL | RET | NOT | EQ | NEQ | GT | LE | GQ | LQ | RNG | LOADS2 | LOADS3 | LOADS4 | LOADS5 | LOADS6 | LOADS7 | LOADS8 | LOADS9 | LOADS10 | LOADSN | SER | NSER | NSER128 | RLE1 | RLE2 | RLE3 | RLE4 | RLE5 | RLE6 | RLE7 | RLE8 | RLE16 | RLE32 | RLE64 | RLE128 | RLE256 | RLE512 | RLEN | OUTLE | OUTBE | OUTB | NOP | CALLN | DEBUG | EXIT deriving (Eq, Ord, Enum, Show) data CmdArg = W32 Word32 | W16 Word16 | W8 Word8 | ADDR Addr data Addr = ALabel Label | AOffset Int data Cmd = Cmd0 Opcode | CmdConst Word32 | Cmd1 Opcode CmdArg | Cmd2 Opcode CmdArg CmdArg | Cmd3 Opcode CmdArg CmdArg CmdArg | CmdJmp Opcode Addr | CmdCondJmp Opcode Addr | CmdLabel Label | RawByte Word8 type Label = Int type Block = (Label, [Cmd])

- , - class OpcodeCL a where isRLE :: a -> Bool arity0 :: a -> Bool arity1 :: a -> Bool arity2 :: a -> Bool arity3 :: a -> Bool firstCode :: a lastCode :: a data Opcode = DUP | DROP | CONST | CRNG | JNZ | JZ | JGQ | JNE | JMP | CALLT | CALL | RET | NOT | EQ | NEQ | GT | LE | GQ | LQ | RNG | LOADS2 | LOADS3 | LOADS4 | LOADS5 | LOADS6 | LOADS7 | LOADS8 | LOADS9 | LOADS10 | LOADSN | SER | NSER | NSER128 | RLE1 | RLE2 | RLE3 | RLE4 | RLE5 | RLE6 | RLE7 | RLE8 | RLE16 | RLE32 | RLE64 | RLE128 | RLE256 | RLE512 | RLEN | OUTLE | OUTBE | OUTB | NOP | CALLN | DEBUG | EXIT deriving (Eq, Ord, Enum, Show) data CmdArg = W32 Word32 | W16 Word16 | W8 Word8 | ADDR Addr data Addr = ALabel Label | AOffset Int data Cmd = Cmd0 Opcode | CmdConst Word32 | Cmd1 Opcode CmdArg | Cmd2 Opcode CmdArg CmdArg | Cmd3 Opcode CmdArg CmdArg CmdArg | CmdJmp Opcode Addr | CmdCondJmp Opcode Addr | CmdLabel Label | RawByte Word8 type Label = Int type Block = (Label, [Cmd])

काश, यहाँ एक सरल हास्केल टाइप सिस्टम याद किया जा रहा है: मैं कमांड्स और उनकी कक्षाओं के लिए संकलन-समय के हमलावरों को सेट करना चाहता हूं, ताकि, उदाहरण के लिए, गलत ओपोड के साथ एक टीम बनाना असंभव हो। लेकिन आप ऐसा नहीं कर सकते हैं, लेकिन आप प्रत्येक ओपकोड के लिए एक अलग प्रकार का परिचय नहीं देना चाहते हैं, जो कमांड के लिए एक प्रचलित डेटा प्रकार है और फिर भी opcodes को उत्पन्न करने के लिए मेटाप्रोग्रामिंग का उपयोग नहीं करना चाहते हैं।

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

तो, एक वर्चुअल मशीन कमांड सिस्टम है, अब हमें अपने नियमों से निर्मित तुलनात्मक पेड़ को संकलित करने की आवश्यकता है:

 mkVMCode :: CmpTree -> [Block] mkVMCode xs = normalize maxl code -- skip scanT :: CmpTree -> GenM () scanT (GEQ n left right) = do s <- newLabel l <- runGen' (scanT left) >>= withLabel r <- runGen' (scanT right) >>= withLabel _ex <- newLabel label s dup cnst n jgq (labelOf r) block l >> jmp _ex block r >> label _ex scanT (CODE []) = op0 EXIT scanT (CODE rules) = mapM_ scanR rules scanR :: Rule -> GenM () scanR ( REQ n code ) = do s <- newLabel code' <- runGen' (scanmC code) >>= withLabel ex <- newLabel label s dup cnst n jne ex block code' label ex scanR ( RANGE ab code ) = do s <- newLabel code' <- runGen' (scanmC code) >>= withLabel ex <- newLabel label s dup crng ab jz ex block code' label ex -- skip

mkVMCode :: CmpTree -> [Block] mkVMCode xs = normalize maxl code -- skip scanT :: CmpTree -> GenM () scanT (GEQ n left right) = do s <- newLabel l <- runGen' (scanT left) >>= withLabel r <- runGen' (scanT right) >>= withLabel _ex <- newLabel label s dup cnst n jgq (labelOf r) block l >> jmp _ex block r >> label _ex scanT (CODE []) = op0 EXIT scanT (CODE rules) = mapM_ scanR rules scanR :: Rule -> GenM () scanR ( REQ n code ) = do s <- newLabel code' <- runGen' (scanmC code) >>= withLabel ex <- newLabel label s dup cnst n jne ex block code' label ex scanR ( RANGE ab code ) = do s <- newLabel code' <- runGen' (scanmC code) >>= withLabel ex <- newLabel label s dup crng ab jz ex block code' label ex -- skip

यहां लेखक का सबसे अच्छा तरीका ईडीएसएल के साथ सामान तैयार करना है, जो लेखक मोनाद के ऊपर बनाया गया है।

तुलनात्मक पेड़ से फ्लैट कोड की पीढ़ी बहुत से "स्नॉट" की ओर ले जाती है, उदाहरण के लिए, ब्लॉक से बाहर निकलने की लंबी श्रृंखलाओं के लिए:

 L1: ... JMP L2 L2: JMP L3 L3: JMP L4 L4: EXIT

L1: ... JMP L2 L2: JMP L3 L3: JMP L4 L4: EXIT

अगले ब्लॉक में कूदना और इतने पर। सामान्यकृत इन विरोधाभासों को समाप्त करता है, और कोड को ब्लॉक में तोड़ता है, जिनमें से प्रत्येक एक लेबल से शुरू होता है, और अगले ब्लॉक कमांड में बिना शर्त कूद के साथ समाप्त होता है। ब्लॉक के अंदर कोई सशर्त या बिना शर्त कूद कमांड नहीं हैं, वे केवल अंत में मान्य हैं। लेबल ऑफ़सेट की गणना के लिए हमें ऐसे ब्लॉक की आवश्यकता है। इसके बाद, आप ब्लॉक को मर्ज कर सकते हैं, अनावश्यक संक्रमणों से पूरी तरह से छुटकारा पा सकते हैं।

हम सुंदर किले छपाई के लिए अपने बायोटेक के लिए शो का उदाहरण लिखेंगे और देखें कि ब्लॉक के अनुकूलन के बाद हमें क्या मिलेगा:

 ... L215: DUP CONST 2122 JGQ L220 DUP CRNG 00000843 00000849 JZ L235 RLE512 00 EXIT L220: DUP CRNG 0000084A 000C8869 JZ L223 LOADS2 BYTE 48 BYTE 45 RLE2 4C LOADS7 BYTE 4F BYTE 20 BYTE 57 BYTE 4F BYTE 52 BYTE 4C BYTE 44 RLE2 21 CALLN 00 EXIT L223: DUP CRNG 000C886A 000E1869 JZ L235 RLE512 00 CALLN 00 ;;       --- ,    EXIT ;;  L235: EXIT ... L0: LOADS5 BYTE 02 BYTE 08 BYTE 20 BYTE 00 BYTE 02 RET ...

... L215: DUP CONST 2122 JGQ L220 DUP CRNG 00000843 00000849 JZ L235 RLE512 00 EXIT L220: DUP CRNG 0000084A 000C8869 JZ L223 LOADS2 BYTE 48 BYTE 45 RLE2 4C LOADS7 BYTE 4F BYTE 20 BYTE 57 BYTE 4F BYTE 52 BYTE 4C BYTE 44 RLE2 21 CALLN 00 EXIT L223: DUP CRNG 000C886A 000E1869 JZ L235 RLE512 00 CALLN 00 ;; --- , EXIT ;; L235: EXIT ... L0: LOADS5 BYTE 02 BYTE 08 BYTE 20 BYTE 00 BYTE 02 RET ...

, , , . यह कर देगा।

- , , , .

, , , , . , , vm , . . -eDSL , , .

Writer, …

 stubs :: String stubs = envFile $ do comment "top of the file" put "#include <stdint.h>" put "#include \"emufatstubs.h\"" defines ... stmt (pt codeType ++ op `assign` "code") endl push a "n" put "for(;;)" braces $ indented $ do put "switch(*op)" braces $ do forM_ codes $ \op -> do put (printf "case %s:" (show op)) indented $ decode op endl put "default:" indented $ exit exitLabel indented $ stmt "return 0" ... decode (CRNG) = do skip "1" stmt (tmp0 `assign` pop a) stmt (tmp1 `assign` decode32) >> skip "4" stmt (tmp2 `assign` decode32) >> skip "4" push a ( _and (tmp0 `gq` tmp1) (tmp0 `lq` tmp2) ) next decode (CALL) = do skip "1" stmt (tmp0 `assign` decode32) >> skip "4" stmt (push' r pc') jump tmp0 ...

stubs :: String stubs = envFile $ do comment "top of the file" put "#include <stdint.h>" put "#include \"emufatstubs.h\"" defines ... stmt (pt codeType ++ op `assign` "code") endl push a "n" put "for(;;)" braces $ indented $ do put "switch(*op)" braces $ do forM_ codes $ \op -> do put (printf "case %s:" (show op)) indented $ decode op endl put "default:" indented $ exit exitLabel indented $ stmt "return 0" ... decode (CRNG) = do skip "1" stmt (tmp0 `assign` pop a) stmt (tmp1 `assign` decode32) >> skip "4" stmt (tmp2 `assign` decode32) >> skip "4" push a ( _and (tmp0 `gq` tmp1) (tmp0 `lq` tmp2) ) next decode (CALL) = do skip "1" stmt (tmp0 `assign` decode32) >> skip "4" stmt (push' r pc') jump tmp0 ...

, :

 #define DEFSTACK(n, t, l) ... #define RESET(a) ... #define PTOP(a) ... #define TOP(a) ... #define POP(a) ... #define PUSH(a,v) ... #define NEXT(x) ... #define JUMP(x, b, o) ... #define SKIP(x, n) ... #define PC(x, b) ... #define DECODE32(op) ... #define DECODE8(op) ... ... DEFSTACK(a, uint32_t, 16); DEFSTACK(r, uint32_t, 8); uint32_t tmp0; uint32_t tmp1; uint32_t tmp2; uint32_t tmp3; ... uint8_t *op = code; PUSH(a, n); for(;;) { switch(*op) { ... case CRNG: SKIP(op, (1)); tmp0 = POP(a); tmp1 = DECODE32(op); SKIP(op, (4)); tmp2 = DECODE32(op); SKIP(op, (4)); PUSH(a, ((tmp0 >= tmp1) && (tmp0 <= tmp2))); NEXT(op); ... case CALL: SKIP(op, (1)); tmp0 = DECODE32(op); SKIP(op, (4)); PUSH(r, PC(op, code)); JUMP(op, code, tmp0); ... case EXIT: goto _exit; default: goto _exit; } } _exit: return 0; ...

#define DEFSTACK(n, t, l) ... #define RESET(a) ... #define PTOP(a) ... #define TOP(a) ... #define POP(a) ... #define PUSH(a,v) ... #define NEXT(x) ... #define JUMP(x, b, o) ... #define SKIP(x, n) ... #define PC(x, b) ... #define DECODE32(op) ... #define DECODE8(op) ... ... DEFSTACK(a, uint32_t, 16); DEFSTACK(r, uint32_t, 8); uint32_t tmp0; uint32_t tmp1; uint32_t tmp2; uint32_t tmp3; ... uint8_t *op = code; PUSH(a, n); for(;;) { switch(*op) { ... case CRNG: SKIP(op, (1)); tmp0 = POP(a); tmp1 = DECODE32(op); SKIP(op, (4)); tmp2 = DECODE32(op); SKIP(op, (4)); PUSH(a, ((tmp0 >= tmp1) && (tmp0 <= tmp2))); NEXT(op); ... case CALL: SKIP(op, (1)); tmp0 = DECODE32(op); SKIP(op, (4)); PUSH(r, PC(op, code)); JUMP(op, code, tmp0); ... case EXIT: goto _exit; default: goto _exit; } } _exit: return 0; ...

, . : switch , , . , , . , . Enum Opcode (. ).

, , , , GCC . GCC, switch-based .

. . — VM , . , , , .

…

 testJne = makeTest $ do [l1, l2] <- replicateM 2 newLabel cnst 1 cnst 2 jne l1 exit label l1 cnst 0xCAFEBABE -- 1 outle cnst 1 cnst 1 jne l2 cnst 0xCAFEBABE -- 2 outle exit label l2 cnst 0xFFFFFFFF outle

testJne = makeTest $ do [l1, l2] <- replicateM 2 newLabel cnst 1 cnst 2 jne l1 exit label l1 cnst 0xCAFEBABE -- 1 outle cnst 1 cnst 1 jne l2 cnst 0xCAFEBABE -- 2 outle exit label l2 cnst 0xFFFFFFFF outle

… -:

 tests = testSuite $ do ... test "testJne" testJne (assert $ do a <- getWord32le b <- getWord32le return $ a == 0xCAFEBABE && b == 0xCAFEBABE)

tests = testSuite $ do ... test "testJne" testJne (assert $ do a <- getWord32le b <- getWord32le return $ a == 0xCAFEBABE && b == 0xCAFEBABE)

 runTest :: String -> Test -> IO Bool runTest path (T{tname=nm, tcode=code, tcheck = tc})= do let bin = toBinary code (inp,out,err,pid) <- runInteractiveProcess path [] Nothing Nothing BS.hPut inp bin hClose inp res <- BS.hGetContents out let r = tc res hPutStrLn stderr (printf "test %-24s : %s" nm (if r then "PASSED" else "FAILED !")) return r ... case args of ... ... -> mapM_ (runTest path) tests ... ...

runTest :: String -> Test -> IO Bool runTest path (T{tname=nm, tcode=code, tcheck = tc})= do let bin = toBinary code (inp,out,err,pid) <- runInteractiveProcess path [] Nothing Nothing BS.hPut inp bin hClose inp res <- BS.hGetContents out let r = tc res hPutStrLn stderr (printf "test %-24s : %s" nm (if r then "PASSED" else "FAILED !")) return r ... case args of ... ... -> mapM_ (runTest path) tests ... ...

, core ( )

 ... test testJgq : PASSED test testJne : PASSED test testCallRet1 : PASSED ...

... test testJgq : PASSED test testJne : PASSED test testCallRet1 : PASSED ...

 ... helloFile = const $ BS8.pack "HELLO WORLD!!" fatSample2 = filesystem $ do file "file0" (16384) helloFile dir "A" $ do file "file1" (megs 100) helloFile dir "C" $ do file "file3" (megs 100) helloFile file "file4" (megs 100) helloFile file "file5" (megs 100) helloFile dir "E" $ emptyDir dir "B" $ do file "file2" (megs 50) emptyFile ... $ ./FatGen bin | cbits/genfat 1000000 > fat.img 521106 / 1000000 ( 13027 kb/s) $ fsck.vfat ./fat.img dosfsck 3.0.9, 31 Jan 2010, FAT32, LFN Free cluster summary uninitialized (should be 15863) ./fat.img: 10 files, 115209/131072 clusters $ sudo mount -o loop ./fat.img /mnt/test2/ $ find /mnt/test2/ /mnt/test2/ /mnt/test2/FILE0 /mnt/test2/A /mnt/test2/A/FILE1 /mnt/test2/A/C /mnt/test2/A/C/FILE3 /mnt/test2/A/C/FILE4 /mnt/test2/A/C/FILE5 /mnt/test2/A/C/E /mnt/test2/B /mnt/test2/B/FILE2

... helloFile = const $ BS8.pack "HELLO WORLD!!" fatSample2 = filesystem $ do file "file0" (16384) helloFile dir "A" $ do file "file1" (megs 100) helloFile dir "C" $ do file "file3" (megs 100) helloFile file "file4" (megs 100) helloFile file "file5" (megs 100) helloFile dir "E" $ emptyDir dir "B" $ do file "file2" (megs 50) emptyFile ... $ ./FatGen bin | cbits/genfat 1000000 > fat.img 521106 / 1000000 ( 13027 kb/s) $ fsck.vfat ./fat.img dosfsck 3.0.9, 31 Jan 2010, FAT32, LFN Free cluster summary uninitialized (should be 15863) ./fat.img: 10 files, 115209/131072 clusters $ sudo mount -o loop ./fat.img /mnt/test2/ $ find /mnt/test2/ /mnt/test2/ /mnt/test2/FILE0 /mnt/test2/A /mnt/test2/A/FILE1 /mnt/test2/A/C /mnt/test2/A/C/FILE3 /mnt/test2/A/C/FILE4 /mnt/test2/A/C/FILE5 /mnt/test2/A/C/E /mnt/test2/B /mnt/test2/B/FILE2

: , . eDSL.

2Kb , 2Kb GSM/EDGE, 3G.

, , .

.

वसा ढूँढना (वसा के लिए क्वेस्ट)

More articles: