Ocsigen या Yoba रिटर्न के साथ गतिशील अनुप्रयोग

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

आज सुबह हम Ocsigen के लिए अपना पहला आवेदन लिखेंगे। जो लोग यह चाहते हैं कि पहले आधिकारिक मैनुअल से परिचित होना अच्छा होगा, हालांकि, आपको बहुत उम्मीद नहीं करनी चाहिए, क्योंकि मैनुअल अधूरा है, विकृत लाइनों के साथ भरा हुआ है ला "??????" और फ्रेंच में बेईमानी भाषा। इसलिए, मैं मुख्य मैनुअल रहूंगा।

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

सबसे पहले, हमें ocsigen सर्वर को स्थापित करने की आवश्यकता है। चूंकि हम वितरण के लिए अभी तक 2.0 संकलित करने में कामयाब नहीं हुए हैं, इसलिए हम इस निर्देश का पालन करेंगे और अपने होम डायरेक्टरी में बंडल सर्वर को इंस्टॉल करेंगे। चलने से पहले बंडल को सही और स्वादिष्ट बनाने के लिए, Makefile.config को संपादित करें और इसे वहां लिखें:
LOCAL := ${HOME}/bin/ocsigen
DEV := YES
OCAMLDUCE := YES
OCLOSURE := YES
OTHERS := YES
Ocaml और Findlib एकत्र नहीं किया जाएगा, वे पहले से ही रिपॉजिटरी में हैं। इस बार हमें ओ'क्लोजर की आवश्यकता नहीं है, लेकिन हम इसे केवल उसी स्थिति में एकत्रित करेंगे - ताकि बाद में हमें ऑक्सीजन पुनः प्राप्त न करना पड़े, यदि आप स्वयं इसमें रुचि रखते हैं या मुझसे एक लेख चाहते हैं।

अगला पैराग्राफ फ़ाइल को तुरंत संपादित करेगा $ {HOME} /bin/ocsigen/etc/ocsigranever/ocsigctorver.conf: सुनिश्चित करें कि उपयुक्त पोर्ट वहाँ पंजीकृत है, साथ ही उपयोगकर्ता और नाम और समूह से शुरू करना है। अब भविष्य की साइट के लिए कॉन्फ़िगरेशन तैयार करने का समय है। $ {HOME} /bin/ocsigen/etc/ocsigctorver/conf.d/yoba.conf बनाएं और इसे सामग्री से भरें:

 <ocsigen> <server> <charset>utf-8</charset> <extension findlib-package="ocsigenserver.ext.staticmod"/> <extension findlib-package="ocsigenserver.ext.ocsipersist-sqlite"> <database file="ocsidb"/> </extension> <extension findlib-package="ocsigenserver.ext.deflatemod" /> <extension findlib-package="eliom.server"/> <host charset="utf-8" hostfilter="*"> <site path="" charset="utf-8"> <static dir="/home/username/yoba" /> <eliom module="/home/username/yoba/_build/server/yoba.cmo"> <cache-size>10000</cache-size> </eliom> </site> <deflate compress="only"> <type>application/x-javascript</type> </deflate> </host> </server> </ocsigen> 

सामग्री के बारे में संक्षेप में:

• staticmod सर्वर को स्थैतिक डेटा वापस करने की अनुमति देता है (हमारे मामले में, यह एक संकलित .js फ़ाइल होगी
• ocsipersist-sqlite - हमें लगातार डेटा के साथ काम करने की अनुमति देता है, फिर हम देखेंगे कि यह क्यों आवश्यक है
• डिफ्लेमेटम, जैसा कि अपेक्षित है, जब इसे भेजा जाता है तो डेटा दबाता है। नीचे आप साइट सेटिंग्स में डिफ्लेट अनुभाग देख सकते हैं, जो कहता है कि हम केवल js दबाते हैं। नोट: आप संपीड़न विधि का चयन नहीं कर सकते - gzip या अपस्फीति - यह स्वचालित रूप से ग्राहक की उम्मीदों के आधार पर चुना जाता है।
• eliom.server फ्रेमवर्क का पूरा सर्वर हिस्सा प्रदान करता है
• हमारे मेजबान के hostfilter पैरामीटर में, हम कहते हैं कि हम सभी डोमेन पर प्रतिक्रिया देते हैं
• और साइट के लिए एक खाली पथ का संकेत देते हुए, हम कहते हैं कि साइट डोमेन के रूट में स्थित है। खाली लाइन की जगह, "योबा" कहें, हम अपनी साइट को सभी स्थैतिक सामग्री के साथ बल देंगे पता होस्टनाम / योबा को - एक असंदिग्ध लाभ, आप एक ही डोमेन पर कई साइटों को रख सकते हैं और उन्हें अपनी पसंद के अनुसार फेरबदल कर सकते हैं।
• / home / username / yoba कोड (और संकलित yoba.js फ़ाइल) के साथ हमारी निर्देशिका होगी, और _build / सर्वर में संकलित सर्वर मॉड्यूल होगा। बेशक, आदर्श रूप से, आपको संकलन करने की आवश्यकता है, फिर कोड को एक अलग फ़ोल्डर में स्थानांतरित करें, और अभी भी संकलित मॉड्यूल के साथ एक ही फ़ोल्डर में स्थिर सामग्री को संग्रहीत न करें, लेकिन अब हम कोड को जल्दी से जांचने के लिए ऐसा करेंगे।

हुर्रे! हम लेखन कोड की ओर मुड़ते हैं।
हम कुख्यात फ़ोल्डर / होम / उपयोगकर्ता नाम / योबा बनाते हैं और आर्काइव को योबा भाषा के साथ डाउनलोड करते हैं - हमने पहले से ही भाषा लिखी है, लेकिन हमारे लिए इसे थोड़ा दर्ज करना और इसे कक्षा में बदलना दिलचस्प नहीं है, इसलिए हम इसे तुरंत ले लेंगे। हम इसे एक ही फ़ोल्डर में अनपैक करते हैं और मानक Makefile.config और Makefile.rules को एक ही स्थान पर डाउनलोड करते हैं - एक प्रोजेक्ट बनाना आसान नहीं है, आप स्क्रैच से एक अंजीर फ़ाइल लिख सकते हैं।
यह कुछ ठीक करने और तुरंत पहले वाक्यविन्यास नवाचारों के बारे में जानने का समय है: एलिओम में, कोड को अनुभागों में रखा जा सकता है। {सर्वर {...}} अनुभाग (अनुभाग के बिना कोड के समान) सर्वर पर संकलित और निष्पादित किया जाता है, क्लाइंट पर {क्लाइंट {...}} अनुभाग संकलित किया जाता है, और {साझा {...}} वहां और वहां दोनों तक पहुंच योग्य है।
चूंकि हमारा दुभाषिया क्लाइंट पर काम करेगा, इसलिए हम yobaLang.ml फ़ाइल का नाम बदलकर yobaLang.eliom करते हैं, इसे खोलें, और बहुत शुरुआत में लाइन "{क्लाइंट {" जोड़ें, और बहुत अंत में बदलें ";;" (दो अर्धविराम - यह केवल कोड के शीर्ष स्तर पर निर्देश का अंत है, उन्हें अब अनुभाग के अंदर उपयोग नहीं किया जा सकता है) "}}"। जब हम इसे लिखते हैं तो उत्पन्न ओम्लेक्स और ओक्मलैक कोड को इसी तरह से मेकफाइल में संपादित किया जाएगा।
इस बीच, एक फाइल लिखिए जो सब कुछ करेगी। इसे कहते हैं, कहते हैं, home.eliom।
फ़ाइल की शुरुआत में, भविष्य के लिए मॉड्यूल खोलें और तुरंत नमूना कोड के साथ एक पंक्ति बनाएं जो आगंतुक को पेश किया जाएगा।

 {shared{ open Eliom_pervasives open Lwt open HTML5.M open Eliom_parameters open Eliom_request_info open Eliom_output.Html5 open Ocsigen_extensions let code_example = ref "                    1     2                                       1     50            " }} 

अगला, हम अपने एप्लिकेशन का एक मॉड्यूल बनाएंगे - क्लाइंट-सर्वर इंटरैक्शन को सही ढंग से काम करने के लिए, सभी सेवाओं को एक एप्लिकेशन की ओर से पंजीकृत किया जाता है। सौभाग्य से, यह आसान है:

 module My_appl = Eliom_output.Eliom_appl ( struct let application_name = "yoba" end) 

एक फ़ंक्शन जोड़ें जो योब पर कोड निष्पादित करेगा और परिणाम लौटाएगा, फ़ंक्शन विशुद्ध रूप से क्लाइंट होगा, सर्वर को इसके बारे में पता नहीं होगा

 {client{ let yoba_execute str = ( let yparser = new YobaLang.yoba_interpretator () in yparser#parse str; yparser#get_output) }} 

एक सेवा बनाएं जो उपयोगकर्ता के अनुरोध को संसाधित करेगी। Ocsigen में सेवाएँ बनाना असामान्य रूप से सरल और सुविधाजनक है, प्रत्येक सेवा को एक तरह से और जोरदार टाइप (!) GET / POST मापदंडों के एक सेट की विशेषता है। तदनुसार, सर्वर अनुरोध के आधार पर अनुरोध को संसाधित करने के लिए कौन सी सेवा तय करता है। आप एक डिफ़ॉल्ट सेवा बना सकते हैं जो मापदंडों के बिना अनुरोधों को संसाधित करेगी, उसी पते पर एक दूसरी सेवा जो एक जीईटी पैरामीटर के साथ अनुरोधों को संसाधित करेगी, और एक पीओटी पैरामीटर के साथ एक तीसरी सेवा। और वे भ्रमित नहीं होंगे। लेकिन अभी के लिए, हमें केवल एक सेवा की आवश्यकता है:

 let empty_service = Eliom_services.service ~path:[""] ~get_params:(Eliom_parameters.unit) ();; 

पथ का प्रतीक है कि सेवा साइट के लिए डिफ़ॉल्ट पथ (अपाचे में एक सूचकांक पृष्ठ के रूप में) के साथ दी जाएगी, और ~ get_params में हमने संकेत दिया कि सेवा मापदंडों को स्वीकार नहीं करती है।

पेज टेम्प्लेट लिखने का समय आ गया है:

 let page_template code_input counter_value = html (head (title (pcdata "Yoba interpreter")) [] ) (body [ h1 [pcdata "Yoba! For human beings"]; p [pcdata "  !  —  !"]; div [ raw_textarea ~a:[a_id "clientcode"] ~name:"clientcode" ~rows:25 ~cols:60 ~value:code_input (); raw_button ~button_type:`Button ~name:"clientbutton" ~a:[a_id "clientbutton"] ~value:"!" [pcdata "!"]; ]; pre ~a:[a_id "clientoutput"] []; hr (); p [pcdata "-  : "; b [pcdata (string_of_int counter_value)]] ]);; 

जैसा कि आप देख सकते हैं, सभी पृष्ठ तत्व ऐसे फ़ंक्शंस हैं जो कड़ाई से परिभाषित मापदंडों को इनपुट के रूप में लेते हैं, जिसके कारण निर्मित HTML पृष्ठ का स्थैतिक प्रकारण किया जाता है। तो, html फंक्शन दो मापदंडों को एक इनपुट के रूप में स्वीकार करता है - एक प्रकार `हेड, और दूसरा टाइप` बॉडी। और div - इनपुट के रूप में लेता है तत्वों की एक सूची div के अंदर होने की अनुमति दी।

लेकिन हम दूसरे पर अधिक विस्तार से ध्यान केंद्रित करते हैं। सबसे पहले, हमारा page_template फ़ंक्शन दो मापदंडों को इनपुट के रूप में स्वीकार करता है - एक कोड और एक आगंतुक काउंटर। पहले को टेक्सारिया में रखा गया है, और दूसरा सबसे नीचे <p> टैग के अंदर है। दूसरे, कच्चे_टेक्स्टेरिया और रॉ_बटन कार्यों के नाम इतने कच्चे हैं - अच्छे कारण के लिए। समान सरल गैर- "रॉ_" फ़ंक्शंस हैं, लेकिन वे अद्भुत, दृढ़ता से टाइप किए गए रूपों के अंदर तत्वों को बनाने के लिए डिज़ाइन किए गए हैं जो हमेशा कुछ सेवा का उल्लेख करते हैं (दूसरे शब्दों में, जब एक फॉर्म बनाते हैं, तो हम तुरंत सत्यापित करते हैं कि यह कड़ाई से आवश्यक सूची को कहां भेजेगा। पैरामीटर)। लेकिन हमारा टेक्स्टारिया और बटन (यह <इनपुट> टैग नहीं है, लेकिन एचटीएमएल 5 से सबसे प्राकृतिक <बटन> टैग) कहीं भी कुछ भी नहीं भेजेगा, लेकिन पृष्ठ के अंदर फ्रॉड होगा, इसलिए उनके पास कोई भी फॉर्म नहीं है। तीसरा, हमने एक विशेष <pre> बनाया, जो हमारे दुभाषिया के परिणामों को संग्रहीत करेगा।

वैसे, क्या मैंने आगंतुकों के काउंटर का उल्लेख किया है? मैं पूरी तरह से भूल गया, चलो इसे लिखो। ऐसा करने के लिए, हम तुरंत दो नए मॉड्यूल: Lwt और Ocsipersist से परिचित होंगे। पहला सहकारी धागे के साथ काम करने के लिए जिम्मेदार है, और दूसरा लगातार भंडारण के लिए है।
ऑक्सीजन प्रवाह प्रणाली सहकारी है। इसका मतलब यह है कि पारंपरिक धागों के बजाय नई प्रक्रिया, कॉल स्टैक और अन्य बकवास के निर्माण की आवश्यकता होती है, हमें बहुत हल्के धागे मिलते हैं (इतना हल्का कि वे लगभग हर कॉल के लिए उपयोग किए जाते हैं)। सभी प्रकार की बकवास बनाने के बजाय, हम थ्रेड्स की ओर मुड़ते हैं, कोड में तथाकथित बनाते हैं सहकारी बिंदु, जिसके आधार पर संकलक स्वयं वह सब कुछ करता है जिसकी आवश्यकता होती है, गतिरोध की संभावना को कम करता है।

 let get_count = let counter_store = Ocsipersist.open_store "counter_store" in let cthr = Ocsipersist.make_persistent counter_store "countpage" 0 in let mutex = Lwt_mutex.create () in (fun () -> cthr >>= (fun c -> Lwt_mutex.lock mutex >>= (fun () -> Ocsipersist.get c >>= (fun oldc -> let newc = oldc + 1 in Ocsipersist.set c newc >>= (fun () -> Lwt_mutex.unlock mutex; return newc) ) ) ) ) ;; 

यदि आप OCaml (जैसे मैंने पहली बार किया था) के लिए बेहिसाब हैं, तो आप देखेंगे कि हमारा कार्य मुश्किल है। Get_count अपने आप में एक "ऑब्जेक्ट" है जो म्यूटेक्स और स्टोरेज ऑब्जेक्ट को स्टोर करता है। जब हम कोड में "get_count" लिखते हैं, तो हमें एक फ़ंक्शन दिया जाता है जो इनपुट लेता है () और उसके बाद ही सभी काम करता है। अब हम फंक्शन में आते हैं। हम तुरंत ट्रिकी ऑपरेटर ">> =" देखते हैं - यह एक विशेष ऑपरेटर है जो पहले तर्क के परिणाम से गुजरता है - थ्रेड - दूसरे तर्क के इनपुट के लिए - फ़ंक्शन जो नया थ्रेड बनाता है। औपचारिक रूप से, ऑपरेटर के हस्ताक्षर इस प्रकार हैं:

 val (>>=) : 'at -> ('a -> 'bt) -> 'bt 

और बहुत अंत में रिटर्न फ़ंक्शन थ्रेड का परिणाम देता है।
ऑक्सिपर्सिस्ट के साथ, सब कुछ स्पष्ट है, यहां तक ​​कि कुछ भी नहीं बताना है।

हम अपने get_count को कहां से बुलाएंगे और पेज का खाका तैयार करेंगे? और यहाँ वह है, व्याख्या कार्य:

 let interpret code = let req = Eliom_request_info.get_ri () in let ref = match Lazy.force_val req.ri_referer with | None -> "" | Some x -> x in Ocsigen_messages.accesslog ("Referer: " ^ ref); get_count() >|= (page_template code);; 

यह सुविधा हमें कुछ और दिलचस्प विशेषताओं से परिचित कराती है। ऑक्सिजन, अफसोस, लॉग को केवल अनुरोधों के बारे में संक्षिप्त जानकारी लिखते हैं - कौन, क्या उपयोगकर्ता एजेंट, कौन सा होस्ट, कौन सा पेज, कब। और मैं एक रेफ़र भी प्राप्त करना चाहता था। खैर, हम अनुरोध के बारे में जानकारी प्राप्त करेंगे, इसके लिए संदर्भदाता को खींच लेंगे। इसे फिर से चालाक रूप से तैयार किया गया है - यह एक ऐसा मूल्य है जो मौजूद नहीं हो सकता है (जैसे कि अन्य भाषाओं में नल), और जिसे आलसी कंप्यूटिंग में भी लपेटा जाता है, अर्थात, जब तक मैंने अनुरोध नहीं किया, तब तक इसे कहीं भी संग्रहीत नहीं किया गया था।
एक और नया ऑपरेटर "> | =" ">> =" के समान है - एकमात्र अंतर यह होने के साथ कि थ्रेड के काम का परिणाम एक फ़ंक्शन के इनपुट को पास किया जाता है कि नया थ्रेड बिल्कुल वापस आने की योजना नहीं करता है।

यही है, समाप्त हो जाओ। यह हमारी सेवा को पंजीकृत करने और कोड की व्याख्या करने का तरीका जानने का समय है:

 My_appl.register empty_service (fun () () -> Eliom_services.onload {{ Js.Opt.iter (Dom_html.document##getElementById (Js.string "clientbutton")) ( fun clntbutton -> clntbutton##onclick <- Dom_html.handler (fun _ -> Js.Opt.iter (Dom_html.document##getElementById (Js.string "clientcode")) ( fun cdinput -> Js.Opt.iter (Dom_html.document##getElementById (Js.string "clientoutput")) ( fun cdoutput -> let cdinputarea = Dom_html.CoerceTo.textarea cdinput in Js.Opt.iter cdinputarea (fun x -> let i = Js.to_string x##value in cdoutput##innerHTML <- Js.string (yoba_execute i) ) ) ); Js._true ) ) }}; interpret !code_example);; 

{{...}} ब्लॉक एक क्लाइंट फंक्शन की तरह है - हम इसे पेज के ऑनलोड हैंडलर में रजिस्टर करते हैं।
क्लाइंट कोड में, हमारा सिंटैक्स थोड़ा अलग होता है। जेएस ऑब्जेक्ट्स के तरीकों का उपयोग करने के लिए, एक ही तेज के बजाय, डबल का उपयोग किया जाता है, इसलिए DOM_html.document ## getElementById सरल "document.getElementById" से मेल खाती है।
कई Js.Opt.iter जो यहां देखे जा सकते हैं, इस तथ्य के कारण है कि getElementById फ़ंक्शन आवश्यक रूप से हमारे लिए कुछ भी वापस नहीं करता है। तदनुसार, Js.Opt.iter परिणाम पर कार्रवाई तभी करेगा जब परिणाम वास्तव में होगा। इसलिए, जिस पृष्ठ पर हम देख रहे थे, उस पर तीन वस्तुओं के लिए हमें चार Js.Opt.iter की आवश्यकता थी। चार - क्योंकि डिफ़ॉल्ट रूप से getElementById फ़ंक्शन एक प्रकार का तत्व देता है जिसमें केवल सबसे सामान्य गुण होते हैं। और textarea में मूल्य संपत्ति प्राप्त करने के लिए, हम अपनी वस्तु (text_html.CoerceTo) को textarea में टाइप करने की कोशिश कर रहे हैं, जो सामान्य मामले में परिणाम की गारंटी नहीं देता है।

इस प्रकार, पंजीकृत सेवा हैंडलर सिर्फ दो चीजें करता है - यह पृष्ठ की शुरुआत में जेएस-कोड को कॉल करता है और ऊपर हमारे टेम्पलेट पर वापस लौटता है।

एक चौकस पाठक पहले से ही देख सकता है और आश्चर्यचकित हो सकता है कि क्यों, बहुत शुरुआत में, मैंने एक स्ट्रिंग (रेफरी) के लिंक के रूप में code_example घोषित किया, और फिर हर जगह इसे डीफ़र कर दिया। और बात यह है कि किसी समय मेरे साथ यह हुआ था कि हमारा योबा वास्तव में सामूहिक होना चाहिए। उपयोगकर्ता ने दूसरों को व्याख्या करने और दिखाने के लिए जो कुछ भी करने की कोशिश की, उसे बचाएं।
ऐसा करने के लिए, पहली सेवा के बगल में, हम एक विशेष रूप से प्रशिक्षित दूसरी सेवा बनाएंगे, जो एक कोड के साथ एक लाइन लेगी और इसे code_example में डाल देगी। जावास्क्रिप्ट से सेवा को कॉल करने के लिए, इसे Eliom_output.Caml की ओर से बनाएं:

 let update_code_service = Eliom_output.Caml.register_service ~path:["update code"] ~get_params:(string "f") (fun f () -> code_example := f; return ());; 

अब हम अपने क्लाइंट फ़ंक्शन (जो कि सबसे आंतरिक है) को बदलते हैं, केवल एक लाइन को जोड़ते हैं:

  let i = Js.to_string x##value in ignore(Eliom_client.call_caml_service ~service:%update_code_service i ()); cdoutput##innerHTML <- Js.string (yoba_execute i) 

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

अंत में, Makefile लिखें:

 MODULE = yoba APP = yoba include Makefile.config SERVERFILES := home.eliom CLIENTFILES := yobaType.ml yobaLexer.eliom yobaParser.eliom yobaLang.eliom home.eliom SERVERLIB := -package eliom.server,ocsigenserver,lwt CLIENTLIB := -package js_of_ocaml INCLUDES = EXTRADIRS = include Makefile.rules yobaParser.eliom: ocamlyacc yobaParser.mly echo '{client{' >yobaParser.eliom cat yobaParser.ml >>yobaParser.eliom echo '}}' >>yobaParser.eliom sed -i 's/;;//' yobaParser.eliom rm yobaParser.ml yobaParser.mli yobaLexer.eliom: yobaParser.eliom ocamllex yobaLexer.mll echo '{client{' >yobaLexer.eliom cat yobaLexer.ml >>yobaLexer.eliom echo '}}' >>yobaLexer.eliom sed -i 's/;;//' yobaLexer.eliom rm yobaLexer.ml _build/client/yobaLexer.cmo: _build/client/yobaParser.cmo _build/client/yobaLang.cmo: _build/client/yobaLexer.cmo _build/client/yobaParser.cmo $(STATICDIR)/$(APP).js: _build/client/${MODULE}.cmo ${JS_OF_ELIOM} -jsopt -pretty -verbose ${CLIENTLIB} -o $@ $^ #yui-compressor --charset utf-8 $@ > $@_min #mv $@_min $@ pack: $(STATICDIR)/$(APP).js 

चूंकि हमें yOBLexer.eliom और yobaParser.eliom उत्पन्न करने की आवश्यकता है, इसलिए हमने इसके लिए उपयुक्त नियम लिखे। इसी तरह, डिफ़ॉल्ट रूप से, डिफ़ॉल्ट निर्भरता जनरेटर हमारे लेसर और पार्सर को संकलित करने के लिए निर्धारित करने के साथ सामना नहीं करता है, इसलिए हमने उसे कुछ नियमों के साथ मदद की।
अब आप चला सकते हैं:
make depend
make
make pack
पहला एक संकलन आदेश उत्पन्न करेगा, दूसरा एक सर्वर कोड संकलित करेगा, और तीसरा एक जावास्क्रिप्ट फ़ाइल उत्पन्न करेगा जो स्वचालित रूप से सर्वर भाग द्वारा कॉल किया जाएगा, हालांकि हमने इस कॉल को पेज टेम्पलेट में पंजीकृत नहीं किया था। यदि आप यू-कंप्रेसर और उसके बाद के एमवी को कॉल को अनसुना करते हैं, तो आप जेएस कोड को थोड़ा संक्षिप्त कर सकते हैं (मेरे मामले में, 400kb से 209kb पर)।
आपको निर्यात PATH लिखकर सभी निर्देशों को पूरा करना होगा जिसके बारे में ocsigctorver विधानसभा ने आपको बहुत अंत में बताया था।

इसके बाद, $ HOME / bin / ocsigen / bin पर जाएं और कहें ./ocsigucerver
ब्राउज़र खोलें और व्याख्या करने का प्रयास करें। और अगर आप बहुत आलसी हैं, तो आप मेरे साथ खिलवाड़ कर सकते हैं: sorokdva.net