आह से टर्मिनल के लिए भागने के क्रम उत्पन्न करना

Question

मैं पोटीन को भेजने के लिए पोटीन बनाने की कोशिश कर रहा हूं, जिसे मैं अपने प्रोग्राम के लिए टर्मिनल पर भी काम करने के लिए कुछ प्रमुख संयोजनों के लिए चाहता हूं।

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

एक उदाहरण:

^F1::SendInput ^[O5P

यह मेरे परीक्षण में 28 देता है।

मैं इसके लिए देखता हूं ^[1 मुझे 377 और के लिए मिलता है ^[2 376, और मैं देखता हूं कि हेक्साडेसिमल नंबरों (ए-एफ) से बाहर के अक्षरों का उपयोग किया जा सकता है, साथ ही साथ ; तथा ~ या डबल [[।

क्या आप समझते हैं कि यह कैसे काम करता है? इसके लिए कोई अच्छी वर्णनात्मक सामग्री? आपका बहुत बहुत धन्यवाद!

Answer 1

यदि आप एक फ़ंक्शन कुंजी को "भेजना" चाहते हैं, तो उपयुक्त सिंटैक्स का उपयोग करें

^F1::SendInput {F5}

इससे पुट्टी को अभिनय करने का कारण होगा जैसे कि आपने F5 दबाया था और फिर यह सर्वर को वर्णों का एक उपयुक्त अनुक्रम (एक एस्केप अनुक्रम) भेजेगा।

               PC                                         Server
   +---------------------+   Network     +-------------------------+
   | [AHK] ----> [Putty] | ============> | [TTY] ------> [Program] |
   |        F5           |  Esc [ 15 ~   |        Esc…    |   ^    |
   +---------------------+               |                |   | F5 |
                                         |                v   |    |
                                         |    $TERM------[Curses]  |
                                         |                 |       |
                                         |    /usr/share/terminfo  |
                                         +-------------------------+

सर्वर पर, एस्केप सीक्वेंस को पहले TTY हैंडलर (इंटरप्ट सिग्नल आदि की तलाश) द्वारा संसाधित किया जाता है और फिर आपके सर्वर प्रोग्राम को दिया जाता है, जो इसे टाइप करता है। curses लाइब्रेरी जो एस्केप सिक्वेंस को फ़ंक्शंस के नामों में बदल देती है। कार्यक्रम तब निर्णय लेता है कि प्राप्त करने के परिणामस्वरूप क्या करना है।

वास्तविक एस्केप सीक्वेंस "टर्मिनल एमुलेशन" पर निर्भर करता है। डिफ़ॉल्ट रूप से, पुट्टी एक xterm का अनुकरण करता है। Curses लाइब्रेरी पर्यावरण वेरिएबल TERM की वैल्यू का उपयोग टर्मऑफ में देखने के लिए करती है कि फंक्शन को एक एस्केप सीक्वेंस द्वारा दर्शाया गया है।

---

फ़ंक्शन कुंजियों के लिए एस्केप सीक्वेंस / etc / termcap में मिल सकते हैं, यहाँ कुछ हैं

                                    SCO     PuTTY    PuTTY
  Key    Termcap  VT100    VT220    ANSI    XTERM    VT400
  ---    -------  -------  -------  ------  ------   -------
  F1     k1       Esc[OP   Esc[OP   Esc[M   Esc[OP   Esc[11~
  F2     k2       Esc[OQ   Esc[OQ   Esc[N   Esc[OQ   Esc[12~
  F3     k3       Esc[OR   Esc[OR   Esc[O   Esc[OR   Esc[13~
  F4     k4       Esc[OS   Esc[OS   Esc[P   Esc[OS   Esc[14~
  F5     k5       -        -        Esc[Q   Esc[15~  Esc[15~
  F6     k6       -        Esc[17~  Esc[R   Esc[17~  Esc[17~
  F7     k7       -        Esc[18~  Esc[S   Esc[18~  Esc[18~
  ...
  F10    k0       -        Esc[21~  Esc[V   Esc[21~  Esc[21~
  F11    k1       -        Esc[23~  Esc[X   Esc[23~  Esc[23~
  ...
  F14    kD       -        Esc[26~  Esc[Z   Esc[26~  Esc[26~
  F15    kE       -        Esc[27~  Esc[a   Esc[27~  Esc[27~
  ...
  F36    FP       -
  ...
  F63    Fr       -

टिप्पणियाँ

• VT100 सीरीज़ में PF1 को PF4 में लेबल करने वाली केवल चार फ़ंक्शन कुंजियाँ थीं
• VT220 में F20 तक 20 फ़ंक्शन कुंजियाँ थीं
• VT220 ने "ब्रेक" फ़ंक्शन के लिए स्थिति 5 पर फ़ंक्शन कुंजी का उपयोग किया। (इसलिए उपरोक्त अंतर)
• सभी एमुलेटर या एक्सटेंडेड टर्मकैप / टर्मोफ फाइल्स उपरोक्त के बारे में सहमत नहीं हैं।
• प्रगति में अजीबोगरीब अंतराल हैं।
• xterm एक परिभाषा नहीं है, यह मिसफिट्स का एक अनियंत्रित परिवार है, कोई दो समान नहीं।
• Ditto "ANSI"
• कई एमुलेटर F13 के लिए Shift + F1 का उपयोग करते हैं, F25 के लिए Alt + F1 आदि
• PuTTY में, Shift + F1 F11 के समान है (F13 नहीं)
• हां यह गड़बड़ है। इसलिए हमने PuTTY और Terminfo को इसे हमसे छिपाने दिया।

Comments

मैं शुद्ध {specialKey} सिंटेक्स जानता था कि मुझे मुख्य संयोजनों की आवश्यकता है। उदाहरण के लिए: + F1 :: SendInput, ^ 6s {F1} और ^ F1 :: SendInput, ^ 6c {F1}

— obeliksz

मुझे यह नहीं मिलता है कि यह एस्केप कोड कैसे बनता है / काम करता है: कोड में संख्या बढ़ने पर यह घटता जाता है (प्रश्न में उदाहरण देखें)। क्या {कुंजी} के लिए जोड़ / घटाव करना संभव है? उदाहरण के लिए: {Enter-3} मैं अपने परीक्षण कार्यक्रम से कोड 13 प्राप्त करता हूं, मैं एक संकेत भेजना चाहता हूं जो 10 लौटता है।

— obeliksz

आपके आंकड़े के अनुसार मुझे लगता है कि xterm टर्मोफ को बदलने के लिए टर्मिनल की प्रतिक्रियाओं को परिवर्तित एस्केप कोड में बदलना चाहिए? मैंने यह कोशिश की (संशोधित शब्दाडंबर और टिक के साथ पुनर्संगठित), लेकिन इसने मेरे संशोधन को कम से कम लागू नहीं किया, इसका कोई प्रभाव नहीं था। क्या मैं सिर्फ टर्म फाइल को गलत समझ रहा था? मुझे लगता है कि अगर सभी TERM ने xterm लौटाया तो मैंने और अधिक xterm टर्मोफ फाइल्स बदल दीं।

— obeliksz

@obelisk: ए) टर्मिनल सर्वर को भेजे गए कोड (केवल उन सर्वर से भेजे गए) पर प्रतिक्रिया नहीं करते हैं। बी) आप पुटी को एस्केप सीक्वेंस भेजने के लिए एएचके का उपयोग करने की कोशिश क्यों कर रहे हैं? पुट्टी को फंक्शन की प्रेस भेजें, पुट्टी को यह तय करने दें कि किस सीक्वेंस को भेजना है। C) टर्मिनेफो लाइब्रेरी (सटीक वर्तनी) में केवल एक "xterm" फ़ाइल है।

— RedGrittyBrick

मैं एएचके का उपयोग कर रहा हूं क्योंकि अन्यथा मैं अपने प्रमुख संयोजनों पर प्रतिक्रिया करने के लिए पोटीन नहीं बना सकता। मैंने आपके उत्तर को स्वीकार कर लिया क्योंकि आपने बताया कि यह कैसे काम करता है, लेकिन यह मेरे लिए काम नहीं करता है ... मैंने यूएसआर / शेयर / टेमीफीनो / ​​एक्स / एक्सटर्म से xterm को संशोधित किया ... संशोधित kf1 / EOP से / EOX और टिक इसे फिर से देखा, लेकिन मुझे इसका असर नहीं दिख रहा है ... मैंने xterm का परीक्षण किया, TERM ने xterm को वापस कर दिया। बिल्ली एफ 1 के लिए मुझे ईओपी से पहले मिला था और अभी भी मुझे सिर्फ ईओपी मिलता है। यह एक हिस्सा है, दूसरे को मैं चाहता हूं कि भागने का कोड मिल जाए, ये पत्र / नंबरिंग कैसे जुड़ते हैं

— obeliksz