$ PATH परिवर्तनीय, लाइन-दर-लाइन निर्यात करें

22

AskUbuntu पर इस सवाल से प्रेरित ।

आपका काम बेहद सरल है। पैठ पर्यावरण चर ( echo $PATH) लें और इसे ऐसे निर्यात करें कि प्रत्येक प्रविष्टि ( :वर्ण द्वारा अलग ) अपनी रेखा पर हो।

उदाहरण के लिए, यदि पेटीएम है /bin:/usr/bin:/usr/local/bin, तो आपका कार्यक्रम आउटपुट होना चाहिए:

/bin
/usr/bin
/usr/local/bin

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

उपर्युक्त प्रश्न के उत्तर में संदर्भ कार्यान्वयन मौजूद हैं।

नियम

  • यह (स्पष्ट रूप से) कोड-गोल्फ है, इसलिए सबसे छोटा उत्तर बेशकीमती हरा चेकमार्क जीत जाएगा।
  • स्वीकृत उत्तर का परीक्षण यह सुनिश्चित करने के लिए किया जाएगा कि यह वास्तव में वैध है।
  • Windows और * nix दोनों प्रविष्टियाँ स्वीकार की जाती हैं।
    • हालाँकि, यदि आप स्पष्ट रूप से विंडोज निर्दिष्ट नहीं करते हैं, तो मैं इसे लिनक्स में चलाने की कोशिश करूंगा और असफल हो जाऊंगा। (यदि यह स्पष्ट है (नमस्ते, बैच!), तो आपको स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है।)
  • प्रति उत्तर केवल एक समाधान है। यदि आपके पास एक विंडोज़ और * निक्स दोनों संस्करण हैं, तो मैं छोटे को गिनूंगा।
  • यदि दो उत्तरों की लंबाई समान है, तो मैं उच्च वोट कुल के साथ प्राथमिकता दूंगा। यदि उनके पास समान वोट हैं, तो मैं पुराने को गिना दूंगा। यदि पोस्ट किया गया समय समान है, तो मैं उसी का चयन करूंगा जो तेजी से निष्पादित होता है। यदि वे एक ही समय में निष्पादित करते हैं, तो मुझे नहीं पता।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  string 
— काज वोल्फ
स्रोत
आह! कुछ गोल्फिंग टिप्स दिए बिना आस्कयूबंटु प्रश्न पर जाना कठिन था।
— रोमन ग्रफ
कुछ (शेल) उत्तरों से लगता है कि पथ में रिक्त स्थान नहीं हैं। क्या उन्हें सुधारा जाना चाहिए?
— डेनिस
@ डेनिस आमतौर पर, पथ चर में रिक्त स्थान नहीं होना चाहिए, लेकिन जैसा कि वे कर सकते हैं, उन्हें सही किया जाना चाहिए। हालाँकि, हम सुरक्षित रूप से मान सकते हैं कि पथ में स्वयं शामिल नहीं होंगे: या एक नई पंक्ति।
— काज वोल्फ
क्या एक समारोह स्वीकार्य है?
— corvus_192
@ corvus_192 जब तक चुनौती स्पष्ट रूप से नहीं कहती, अन्यथा कार्यों की अनुमति है।
— डेनिस

जवाबों:

12

जेड शेल (zsh), 13 बाइट्स

<<<${(F)path}

$pathपैरामीटर का उपयोग करता है , जो शेल द्वारा उपयोग किया जाने वाला एक विशेष सरणी पैरामीटर है जो पैरामीटर से बंधा हुआ है $PATH, और नई सुर्खियों में एक सरणी में शामिल होने के लिए एक पैरामीटर विस्तार ध्वज है।

— मीलों
स्रोत
3
जाहिरा तौर पर एक करता है बस बाहर गोल्फ @Dennis ... हुह।
— wizzwizz4
इस पर कुछ शब्द उर्फ ​​कैसे करें? मैंने कोशिश की alias path="<<<${(F)path}"लेकिन जब इस पर अमल किया गया तो प्रिंट /usr/local/bin zsh: no such file or directory: /Library/Apple/usr/bin zsh: no such file or directory: /Library/Apple/binकरता हैsbin
— डैनियल स्प्रिंगर
@DanielSpringer $ पथ को उपनाम की परिभाषा के दौरान विस्तारित किया जा रहा है, जिसे आप नहीं चाहते हैं। इसके बजाय सिंगल कोट्स का प्रयोग करें:alias path='<<<${(F)path}'
— GammaFunction
@GammaFunction ने काम किया! डबल कोट्स ने काम क्यों नहीं किया?
— डैनियल स्प्रिंगर
@DanielSpringe समझाने के लिए यहाँ बहुत जगह नहीं है, यहाँ एक pastebin है: ix.io/1RyW
— GammaFunction
13

बैश / कोरुटिल्स, 17 16 बाइट्स

tr : '
'<<<$PATH
— सर्गी कोलोडियाज़नी
स्रोत
tr : '\n'<<<$PATHके रूप में अच्छी तरह से काम करना चाहिए
— Arnauld
ऐसा होता है । । । अभी संपादन
— सेर्गेई कोलोडियाज़नी
मुझे लगता है कि आप रिक्त स्थान को हटा सकते हैं चारों ओर <<<के रूप में अच्छी तरह से (उबंटू केवल पर परीक्षण)
— Arnauld
@Arnauld मैं कि उबंटू केवल एक चीज है, यह बैश बात है, तो distros करवाते काम करना चाहिए नहीं लगता कि
— सर्गी Kolodyazhnyy
6
यह किसी भी बाइट को नहीं बचाता है, लेकिन \\nउद्धृत चर के बजाय का उपयोग करना अधिक पठनीय है।
— डेनिस
10

बैच, 41 बाइट्स

@for %%a in ("%PATH:;=";"%")do @echo %%~a

PATHविंडोज के पाठ्यक्रम पर अर्धविराम-सीमांकित है। आसानी से, forडिफ़ॉल्ट रूप से सेमीकॉलन पर विभाजन होता है, लेकिन असुविधाजनक रूप से, रिक्त स्थान पर भी, इसलिए मुझे विभाजन से पहले प्रत्येक पथ तत्व को उद्धृत करने के लिए स्ट्रिंग रिप्लेसमेंट स्ट्रिंग का उपयोग करना होगा। यह बाद में उद्धरणों को हटाने के लिए बनी हुई है।

— नील
स्रोत
1
कमांड लाइन आप की जगह ले सकता से चल रहा है %%के साथ %2 बाइट्स बचत।
— डेविडपोस्टिल
@DavidPostill ऐसा नहीं होगा जो इसे एक प्रोग्राम के बजाय एक कोड स्निपेट बना दे?
— नील
मुझे यकीन नहीं है कि सटीक कोड गोल्फ नियम क्या हैं, लेकिन अधिकांश उत्तर केवल स्निपेट के रूप में नहीं हैं? उनमें से अधिकांश को चलाने के लिए कुछ विवरण के "शेल" की आवश्यकता होती है ...
— डेविडपोस्टिल
9

जेड शेल (zsh), 15 बाइट्स

<<<${PATH//:/
}

आप Anarchy Golf पर कोड का परीक्षण कर सकते हैं : उपयोग फ़ॉर्म पर क्लिक करें , zsh का चयन करें , कोड पेस्ट करें और सबमिट करें।

बैश (शुद्ध), 19 बाइट्स

echo "${PATH//:/
}"

एक ही विचार है, लेकिन बैश कम गोल्फ सिंटैक्स के साथ। Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
6

पॉवरशेल, 20 बाइट्स

$env:PATH-split':'

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

  • -2 बाइट्स बंद। @TimmyD को धन्यवाद

पुराना:

$env:PATH.split(":")
— रोमन ग्रैफ़
स्रोत
5

रूबी, 25 बाइट्स

puts ENV["PATH"].split":"
— अनवर
स्रोत
AskUbuntu पर मूल प्रश्न पर मेरे उत्तर की तुलना में अच्छा, थोड़ा सा छोटा
— Sergiy Kolodyazhnyy
आपको केवल कार्यक्रम ही रूबी आह्वान की गणना करने की आवश्यकता नहीं है, इसलिए यह केवल 26 बाइट्स है।
— जोर्डन
@ जोर्डन को यह पता नहीं था। यह FAQ में है?
— अनवर
@ जोर्डन यह दौरे में ही दिखाया गया है। तो, संपादित किया। आपको यह बताने के लिए धन्यवाद
— अनवर
1
ओह, आप भी 1 बाइट के split ":"लिए split":"या के split ?:लिए बदल सकते हैं ।
— जॉर्डन
4

पर्ल, 22 बाइट्स

say$ENV{PATH}=~y/:/
/r

जरूरत है -Eया -M5.010चलाने के लिए:

perl -E 'say$ENV{PATH}=~y/:/
/r'
— बापू
स्रोत
3

बैश + पायथन, 43 बाइट्स

आइए शेल के चर विस्तार का उपयोग करें। यह कॉलिंग को समाप्त कर देता है os.environ, इस प्रकार कम कोड और कम आयात होता है। इससे पहले कि हम 43 बाइट्स प्राप्त करते हैं, हमें 46 बाइट्स देता है, और xnorट्रिक और स्पेस हटाने के साथ -c।

python -c"print('$PATH'.replace(*':\n'))"
— सर्गी कोलोडियाज़नी
स्रोत
ध्यान दें कि यह विफल हो जाता है यदि आपके PATH में एकल उद्धरण या बैकस्लैश वाली कोई निर्देशिका दिखाई देती है।
— जॉय मैरिएर
@JoeyMarianer चूँकि फ़ाइल नाम / पथ स्ट्रिंग में लगभग कोई भी चरित्र हो सकता है, तो हाँ - यह विफल हो सकता है और PATH का विस्तार '/ dir'1: / dir2' तक होगा, जो कि अजगर को गलत रूप से स्वरूपित कमांड देता है। बैकस्लैश आवश्यक रूप से विफल नहीं होता है - यह केवल व्याख्या करता है कि स्ट्रिंग में क्या है। IMHO, बैकस्लैश एस्केप सामान्य उपयोगकर्ता के पथ नामों में प्रकट नहीं होना चाहिए, इसलिए 99% मामलों में यह ठीक है। हालाँकि मैं सहमत हूँ - इस बात को कभी भी ध्यान में रखा जाना चाहिए क्योंकि आप सीधे या परोक्ष रूप से इस मामले में निपटते हैं
— Sergiy Kolodyazhnyy
3

जावा, 58 बाइट्स

System.out.print(System.getenv("Path").replace(';','\n'));

पूर्ण कार्यक्रम: 106 बाइट्स

class E {
    public static void main (String[] args) {
        System.out.print(System.getenv("Path").replace(';', '\n'));
    }
}
— NoddySevens
स्रोत
3

GNU sed+ bash, 25 बाइट्स:

sed 's/:/\n/g' <<<"$PATH"

यदि PATHव्हॉट्सएप के साथ कोई निर्देशिका नाम नहीं है, तो किसी भी उद्धरण की आवश्यकता नहीं है, 23 बाइट्स:

sed 's/:/\n/g' <<<$PATH

यहां तक ​​कि छोटी, :न्यूलाइन में अनुवाद करना, @ डेनिस के लिए धन्यवाद :

sed y/:/\\n/<<<"$PATH"
— heemayl
स्रोत
3

विम, 19 बाइट्स

"=$PATH<CR>p:s/:/\r/g<CR>

$PATHएक्सप्रेशन रजिस्टर से पकड़ें और पेस्ट करें। :एस को नई सूचियों में बदलें । कुछ भी मुश्किल नहीं है।

— udioica
स्रोत
उन्हें इसे विम ट्यूटोरियल में डालना चाहिए। जैसा कि कोई विम में पाने के बारे में पढ़ रहा है मैं इस उदाहरण की सराहना करता हूं।
— loa_in_
2

PHP, 36 35 33 32 बाइट्स

सहेजे गए 1 बाइट, ब्लैकहोल के लिए धन्यवाद,
2 बाइट्स के लिए धन्यवाद, user59178 के लिए धन्यवाद
1 बाइट बचाया, मार्टिज़न के लिए धन्यवाद

* निक्स संस्करण

<?=strtr(getenv(PATH),":","
")?>

विंडोज संस्करण

<?=strtr(getenv(PATH),";","
")?>
— Arnauld
स्रोत
1
@ RomanGräf *nixसिर्फ यूनिक्स जैसी प्रणाली का जिक्र करने का एक तरीका है।
— Arnauld
1
यदि आप "मल्टी-प्लैटफॉर्म" संस्करण चाहते हैं, तो आप निरंतर उपयोग कर सकते हैंPATH_SEPARATOR
— इस्माइल मिगुएल
1
उपयोग न करें \n, लेकिन इसके बजाय एक सच्ची newline, यह आपको एक बाइट बचाएगा।
— ब्लैकहोल
1
तुम भी "चारों ओर एस ड्रॉप कर सकते हैं PATH। आपको "अपरिभाषित स्थिर" नोटिस का उपयोग मिलता है, लेकिन यह अभी भी काम करता है, आपको 2 बाइट्स बचाता है।
— user59178
1
लघु प्रतिध्वनि <?=strtr(getenv(PATH),":","")?>तिजोरी का उपयोग करके एक बाइट (टिप्पणियों में * केंट न्यूलाइन)
— मार्टिज़न
2

पायथन 2, 49 बाइट्स

सहेजा जा रहा है 2 @xnor और 1 बाइट के लिए धन्यवाद बाइट्स की जगह environके साथ getenv@Serg और @Oliver करने के लिए धन्यवाद

import os
print os.getenv('PATH').replace(*':\n')

अजगर 3 के लिए, बस जोड़ने (और )चारों ओर printतर्क और बाइट संख्या में 1 जोड़।

— कार्ल नेफ
स्रोत
यह कैसे इनपुट प्राप्त करेगा?
— अनवर
2
@ असनियर से 'अचयन' ['पाथ'], जो स्ट्रिंग लौटेगा
— सर्गी कोलोडियाज़नी
1
@ शेर आह। समझ गया।
— अनवर
2
replaceपैक्ड तर्क ले सकते हैं replace(*':\n')।
— xnor
3
@KarlNapf हाँ, यह बात है। यह कार्यक्रम जैसा कि पायथन 3 में नहीं चलता है, इसलिए आपको इसके साथ काम करने वाले संस्करण को निर्दिष्ट करना चाहिए।
— डेन्कर
2

सी, 85 84 बाइट्स

-1 बाइट का उपयोग करने के लिए #import

#import<stdlib.h>
main(){char*a=getenv("PATH");while(*a)putchar(*a++==58?10:a[-1]);}
— कार्ल नेफ
स्रोत
1

रैकेट 39 बाइट्स

@Heemayl की sed कमांड का उपयोग करना:

(system "sed 's/:/\\n/g' <<<\"$PATH\"")

Ungolfed: 

(define (f)
  (system "sed 's/:/\\n/g' <<<\"$PATH\"")
)

परीक्षण:
(एफ)

आउटपुट: 

/usr/local/bin
/usr/bin
/bin
/usr/games
/usr/lib/java/bin
/usr/lib/java/jre/bin
#t
— rnso
स्रोत
1

स्काला, 31 बाइट्स

sys env "PATH"replace(':','\n')

Scala में, के a b cलिए वाक्य रचना चीनी है a.b(c), इसलिए यह करने के लिए संकलित करता हैsys.env("PATH").replace(':','\n')

— corvus_192
स्रोत
1

सी #, 64 बाइट्स

x=>Environment.GetEnvironmentVariable("PATH").Replace(";","\n");

अनाम फ़ंक्शन जो पथ चर देता है, प्रत्येक निर्देशिका एक अलग लाइन पर। ध्यान दें कि xउपयोग करने के बजाय 1 बाइट बचाने के लिए सिर्फ एक डमी ऑब्जेक्ट है ()।

पूरा कार्यक्रम:

using System;

namespace ExportPathVariable
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object,string>f= x=>Environment.GetEnvironmentVariable("PATH").Replace(";","\n");

            Console.WriteLine(f(0));
        }
    }
}

यूनिक्स प्रणालियों पर भी काम करता है अगर आप के ;साथ प्रतिस्थापित करते हैं :, मान लें कि मोनो लाइब्रेरी उपलब्ध हैं। इसे ideone पर ऑनलाइन आज़माएं , .NET Fiddle सुरक्षा अपवाद देता है।

वैकल्पिक रूप से, एक पूर्ण C # प्रोग्राम, जो क्रिया है:

सी #, 118 बाइट्स

using System;class P{static void Main(){Console.Write(Environment.GetEnvironmentVariable("PATH").Replace(";","\n"));}}
— adrianmp
स्रोत
1

हास्केल, 72 बाइट्स

import System.Environment
m ':'='\n'
m x=x 
map m<$>getEnv"PATH">>=putStr

एक महंगा आयात और replaceमानक पुस्तकालय के भीतर कोई इसे काफी लंबा नहीं बनाता है।

— nimi
स्रोत
निश्चित रूप से m ':'...उस स्थान की आवश्यकता नहीं है?
— बिल्ली 10
1
@ स्थान: स्थान अनिवार्य है, क्योंकि 'पहचानकर्ताओं के भीतर एक वैध चरित्र है। अंतरिक्ष के बिना हम नामित एक फ़ंक्शन को परिभाषित करेंगे m'।
— nimi
1

सी (x86), 60 बाइट्स

f(){char*p=getenv("PATH");for(;*p;p++)putchar(*p-58?*p:10);}

यह stdlib.h को शामिल किए बिना 64-बिट प्लेटफार्मों पर काम नहीं करेगा , क्योंकि getenv एक इंट (32 बिट्स) देता है जबकि चार पॉइंट्स चौड़े हैं।

मुझे अभी तक एक ऑनलाइन 32-बिट सी कंपाइलर ढूंढना है।

सी (x86-64), 70 बाइट्स

f(){char*getenv(),*p=getenv("PATH");for(;*p;p++)putchar(*p-58?*p:10);}

सहित के बजाय stdlib.h , हम घोषित getenv एक लौटने एक समारोह के रूप खुद चार सूचक।

मैंने इसे gcc के साथ परीक्षण किया है और लिनक्स पर क्लैंग; अन्य सेटअप रक्त रो सकते हैं। Ideone पर इसे आज़माएं ।

— डेनिस
स्रोत
1

फैक्टर , 28 बाइट्स

यूनिक्स-पसंद के लिए। मुझे पता नहीं है कि यह विंडोज पर कैसे करना है क्योंकि मैं विंडोज बॉक्स में नहीं हूं।

"PATH"getenv ":" "\n"replace
— बिल्ली
स्रोत
1

jq, 18 वर्ण

(16 वर्ण कोड + 2 वर्ण कमांड लाइन विकल्प)

env.PATH/":"|.[]

नमूना रन:

bash-4.3$ PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'

bash-4.3$ jq -nr 'env.PATH/":"|.[]'
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
— आदमी काम पर है
स्रोत
1

अवाक, ५१ ४४ अक्षर

BEGIN{$0=ENVIRON["PATH"];gsub(":",RS);print}

करने के लिए धन्यवाद:

  • gsub()निर्मित चर (-7 वर्ण) में हेरफेर करने के बजाय उपयोग करने का सुझाव देने के लिए निंजाल

विशिष्ट awkतरीका बिल्ट-इन वैरिएबल सेट करना होगा जो प्रभावित करता awkहै कि डेटा को स्वचालित रूप से कैसे हेरफेर किया जाता है:

BEGIN{FS=":";OFS=RS;$0=ENVIRON["PATH"];$1=$1;print}

नमूना रन:

bash-4.3$ PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'

bash-4.3$ awk 'BEGIN{FS=":";OFS=RS;$0=ENVIRON["PATH"];$1=$1;print}'
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
— आदमी काम पर है
स्रोत
रवींद्र। आप ठीक कह रहे हैं, @njjalj मुझे इसे awkविशिष्ट तरीके से करने पर ध्यान केंद्रित करना था । धन्यवाद।
— मैनटवर्क
0

Node.js, 36 बाइट्स

_=>process.env.PATH.split`:`.join`
`

बहुत सीधा।

— Huntro
स्रोत
0

MATLAB, 34 बाइट्स

disp(strrep(getenv('PATH'),58,10))

यहां ऑक्टेव में एक मामूली डेमो दिया गया है, जिसमें मामूली संशोधन है क्योंकि strrepऑक्टेव में दूसरे और तीसरे इनपुट की आवश्यकता होती है, क्योंकि charन्यूमेरिक वैल्यूज के बजाय यह वैरिएबल होता है।

— Suever
स्रोत
0

गेमा, 36 वर्ण

\A=@subst{\\:=\\n;@getenv{PATH}}@end

नमूना रन:

bash-4.3$ PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'

bash-4.3$ gema '\A=@subst{\\:=\\n;@getenv{PATH}}@end'
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
— आदमी काम पर है
स्रोत
0

Befunge-98 + EVAR फिंगरप्रिंट, 34 बाइट्स

"RAVE"4("HTAP"Gv
:!k@:':-!'0*-, >

"RAVE"4(पर्यावरण चर को आसानी से एक्सेस करने के लिए EVAR फिंगरप्रिंट ( ) लोड करता है, PATH envvar ( "HTAP"G) प्राप्त करता है, और प्रत्येक वर्ण के लिए, प्रोग्राम से बाहर निकलता है यदि चरित्र "\ 0" है ( :!k@), ASCII 48 "0 को हटाता है यदि चार्ट ASCII 58 है तो ":" ( :':-!'0*-), और चरित्र को आउटपुट करता है ( ,)।

— ninjalj
स्रोत
0

ईएलएफ / x86, 78 बाइट्स

00000000  7f 45 4c 46 01 00 00 00  43 0f 00 00 43 5f eb 10  |.ELF....C...C_..|
00000010  02 00 03 00 0c 50 eb 10  0c 50 eb 10 04 00 00 00  |.....P...P......|
00000020  5f 5f b1 05 be 49 50 eb  10 3d 20 00 01 00 5f f3  |__...IP..= ..._.|
00000030  a6 75 ef 89 f9 80 3f 3a  75 03 80 2f 30 42 ae 75  |.u....?:u../0B.u|
00000040  f4 4a 04 04 cd 80 93 cd  80 50 41 54 48 3d        |.J.......PATH=|
0000004e

NASM स्रोत:

BITS 32                                         ;
ORG 0x10eb5000                                  ;
                                                ;   ELF HEADER    --   PROGRAM HEADER
; ELF HEADER                                    ; +-------------+
DB 0x7f,'E','L','F'                             ; | magic       |    +--------------------+
                                                ; |             |    |                    |
; PROGRAM HEADERS                               ; |             |    |                    |
DD 1                                            ; |*class   32b | -- | type: PT_LOAD      |
                                                ; |*data   none |    |                    |
                                                ; |*version   0 |    |                    |
                                                ; |*ABI    SysV |    |                    |
DD 0xf43        ; offset = vaddr & (PAGE_SIZE-1); |*ABI vers    | -- | offset             |
                                                ; |             |    |                    |
entry:  inc     ebx     ; STDOUT_FILENO         ; |*PADx7       | -- | vaddr = 0x10eb5f43 |
        pop     edi     ; discard argc          ; |             |    |                    |
        jmp     short skip                      ; |             |    |                    |
DW 2                                            ; | ET_EXEC     | -- |*paddr LO           |
DW 3                                            ; | EM_386      | -- |*paddr HI           |
DD 0x10eb500c                                   ; |*version     | -- | filesz             |
DD 0x10eb500c                                   ; | entry point | -- | memsz              |
DD 4                                            ; | ph offset   | -- | flags: RX          |
                                                ; |             |    |                    |
skip:   pop     edi     ; discard argv[0]       ; |*sh offset   | -- |*align              |
        pop     edi     ; discard argv[1]=NULL  ; |             |    |                    |
env:    mov     cl,5    ; \ strlen("PATH=")     ; |             |    |                    |
        mov     esi,PATH; > "PATH="             ; |*flags    /--|    |                    |
DB 0x3d         ; cmp eax,0x10020               ; |*ehsize      |    +--------------------+
DW 32                                           ; | phentsize   |
DW 1                                            ; | phnum       |
                                                ; |             |
        pop     edi     ; > envp                ; |*shentsize   |
        repe    cmpsb   ; > strcmp(envp,"PATH="); |*shnum       |
        jne     env     ; /                     ; |*shstrndx    |
        mov     ecx,edi                         ; +-------------+

nlcolon:cmp     byte[edi],58  ; \ if (char == ':')
        jne     nosub         ; >
        sub     byte[edi],48  ; >   char -= '0'
nosub:  inc     edx           ; > wlen++
        scasb                 ; >
        jne     nlcolon       ; / while(char != 0)

        dec     edx           ; wlen--
        add     al,4
        int     0x80          ; write(1, ecx, wlen)
        xchg    eax,ebx
        int     0x80          ; exit(...)

PATH: db "PATH="
— ninjalj
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.