सबसे छोटा बायोटेक इंटरप्रेटर / वी.एम.

17

लीडरबोर्ड - JIT संकलित (कम बेहतर है)

  1. es1024 - 81.2 अंक (एक काम कर रहे संकलक सहित!)
  2. कीथ रैंडल - 116 अंक
  3. इल - 121 अंक

लीडरबोर्ड - व्याख्या की गई (कम बेहतर है)

  1. मार्टिन ब्यूटनर - 706654 अंक (लगभग 2 घंटे)।
  2. criptych - 30379 अंक (97 सेकंड)

आपका मिशन, क्या आपको इसे स्वीकार करने का विकल्प चुनना चाहिए, यह संभव है कि सबसे छोटा संभव बायटेकोड दुभाषिया / वीएम लिखा जाए। VM / दुभाषिया एक छोटी CISC वास्तुकला का उपयोग करता है (संचालन आकार में भिन्न हो सकता है), नीचे दी गई भाषा के साथ। पूरा होने पर, आपको यह साबित करने के लिए कि सही आउटपुट (3,126,900,366) मुद्रित करने के लिए 3 सीपीयू रजिस्टर का मूल्य प्रिंट करना होगा।

संकलक

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

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

"वीएम" विनिर्देशों

वीएम में 3 32 बिट अहस्ताक्षरित अभिन्न रजिस्टर हैं: आर 0, आर 1, आर 2। उन्हें 0x00, 0x01 और 0x02 के रूप में हेक्स में दर्शाया गया है।

निम्नलिखित कार्यों का समर्थन किया जाना चाहिए:

प्रारूप [नाम] [... ऑपरेंड्स ...], [हेक्साडेसिमल ऑप-कोड] [... ऑपरेंड्स ने दोहराया ...]

  • लोड [रजिस्टर] [4 बाइट मूल्य], 0x00 [रजिस्टर] [4 बाइट मूल्य]
  • PUSH [रजिस्टर], 0x02 [रजिस्टर]
  • पीओपी [रजिस्टर], 0x03 [रजिस्टर]
  • ADD [रजिस्टर, 1 बाइट] [रजिस्टर, 1 बाइट], 0x04 [रजिस्टर] [रजिस्टर]
  • SUB [रजिस्टर, 1 बाइट] [रजिस्टर, 1 बाइट], 0x05 [रजिस्टर] [रजिस्टर]
  • MUL [रजिस्टर, 1 बाइट] [रजिस्टर, 1 बाइट], 0x06 [रजिस्टर] [रजिस्टर]
  • DIV [रजिस्टर, 1 बाइट] [रजिस्टर, 1 बाइट], 0x07 [रजिस्टर] [रजिस्टर]
  • JMP [कोड लाइन, 4 बाइट्स], 0x08 [4 बाइट कोड लाइन नंबर]
  • सीएमपी [रजिस्टर, 1 बाइट] [रजिस्टर, 1 बाइट], 0x09 [रजिस्टर] [रजिस्टर]
  • BRANCHLT [कोड लाइन, 4 बाइट्स], 0x0a [4 बाइट कोड लाइन नंबर]

कुछ नोट:

  • ऊपर दिए गए गणित के संचालन में पहले रजिस्टर में आउटपुट देते हुए, एक साथ 2 रजिस्टरों के मूल्यों को जोड़ा जाता है।
  • सीएमपी, तुलना ऑपरेटर, को 2 रजिस्टरों के मूल्यों की तुलना करनी चाहिए और शाखा निर्देशों पर भविष्य के उपयोग के लिए आउटपुट को कुछ आंतरिक ध्वज (यह कार्यान्वयन विशिष्ट हो सकता है) में संग्रहीत करना चाहिए।
  • यदि BRANCH को CMP से पहले बुलाया जाता है, जब तक BRANCHEQ को नहीं बुलाया जाता है, "VM" को शाखा नहीं देना चाहिए।
  • PUSH / POP स्टैक से अनिश्चित रूप से पुश या पॉप नंबर।
  • जंप और ब्रांच ऑपरेटर एक विशिष्ट ऑपरेशन (कोड की लाइन) पर कूदते हैं, न कि बाइनरी एड्रेस।
  • शाखा संचालन तुलना नहीं करते हैं। बल्कि, वे आउटपुट को निष्पादित करने की अंतिम तुलना से लेते हैं।
  • ब्रांच और जंप ऑपरेटर एक शून्य आधारित लाइन नंबर इंडेक्सिंग सिस्टम का उपयोग करते हैं। (जैसे JMP 0 पहली पंक्ति में कूदता है)
  • सभी ऑपरेशनों को अहस्ताक्षरित नंबरों पर किया जाना चाहिए, जो शून्य पर ओवरफ्लो करते हैं और पूर्णांक ओवरफ्लो पर एक अपवाद नहीं फेंकते हैं।
  • शून्य द्वारा विभाजन की अनुमति नहीं है और इस तरह, कार्यक्रम के व्यवहार को परिभाषित नहीं किया गया है। आप कर सकते हैं (उदाहरण के लिए) ...
    • प्रोग्राम को क्रैश करें।
    • VM का निष्पादन समाप्त करें और इसे वर्तमान स्थिति में लौटाएं।
    • एक "ERR: Division by 0" संदेश दिखाएं।
  • कार्यक्रम की समाप्ति को तब परिभाषित किया जाता है जब अनुदेश सूचक कार्यक्रम के अंत तक पहुंच जाता है (एक गैर खाली कार्यक्रम माना जा सकता है)।

उत्पादन वास्तव में यह होना चाहिए (newlines शामिल)

R0 3126900366
R1 0
R2 10000

अंक सूत्र की गणना निम्न सूत्र के आधार पर की जाती है:Number Of Characters * (Seconds Needed To Run / 2)

अलग-अलग समय के कारण होने वाले हार्डवेयर अंतर से बचने के लिए, प्रत्येक परीक्षण मेरे कंप्यूटर (i5-4210u, 8GB ram) पर या तो ubuntu सर्वर या विंडोज 8 में चलाया जाएगा, इसलिए कोशिश करें कि कुछ पागल-विदेशी-रनटाइम का उपयोग न करें जो केवल दोहरी G5 पर संकलित करता है मैक प्रो बिल्कुल 762.66 एमबी मुक्त रैम के साथ।

यदि आप एक विशेष रनटाइम / भाषा का उपयोग कर रहे हैं, तो कृपया इसके लिए एक लिंक पोस्ट करें।

  • इच्छुक पार्टियों के लिए, मैंने परीक्षण कोड (C # में लिखा है) यहां पोस्ट किया है: http://pastebin.com/WYCG5Uqu

परीक्षण कार्यक्रम

से आइडिया आया यहाँ है , इसलिए हम उनके कार्यक्रम के कुछ संशोधित संस्करण का उपयोग करेंगे।

कार्यक्रम के लिए सही आउटपुट है: 3,126,900,366

सी में:

int s, i, j;
for (s = 0, i = 0; i < 10000; i++) {
    for (j = 0; j < 10000; j++)
        s += (i * j) / 3;
}

कोड में: [R0 s का प्रतिनिधि है, J का R1, i का R2]

LOAD R0 0
LOAD R2 0 <--outer loop value
LOAD R1 0 <--inner loop value
     --Begin inner loop--
PUSH R1 <--push inner loop value to the stack
MUL R1 R2 <--(i*j)
PUSH R2
LOAD R2 3
DIV R1 R2 <-- / 3
POP R2
ADD R0 R1 <-- s+=
POP R1
PUSH R2 
LOAD R2 1
ADD R1 R2 <--j++
POP R2
PUSH R2
LOAD R2 10000
CMP R1 R2 <-- j < 10000
POP R2
BRANCHLT 3 <--Go back to beginning inner loop
--Drop To outer loop--
LOAD R1 1
ADD R2 R1 <--i++
LOAD R1 10000
CMP R2 R1 <-- i < 10000
LOAD R1 0 <--Reset inner loop
BRANCHLT 2

बाइनरी / हेक्स में:

0x00 0x00 0x00 0x00 0x00 0x00
0x00 0x02 0x00 0x00 0x00 0x00
0x00 0x01 0x00 0x00 0x00 0x00
0x02 0x01
0x06 0x01 0x02
0x02 0x02
0x00 0x02 0x00 0x00 0x00 0x03
0x07 0x01 0x02
0x03 0x02
0x04 0x00 0x01
0x03 0x01
0x02 0x02
0x00 0x02 0x00 0x00 0x00 0x01
0x04 0x01 0x02
0x03 0x02
0x02 0x02
0x00 0x02 0x00 0x00 0x27 0x10
0x09 0x01 0x02
0x03 0x02
0x0a 0x00 0x00 0x00 0x03
0x00 0x01 0x00 0x00 0x00 0x01
0x04 0x02 0x01
0x00 0x01 0x00 0x00 0x27 0x10
0x09 0x02 0x01
0x00 0x01 0x00 0x00 0x00 0x00
0x0a 0x00 0x00 0x00 0x02

बोनस अंक (प्रभाव गुणक रूप से लागू किए जाते हैं) जैसे यदि आप तीनों के लिए अर्हता प्राप्त करते हैं, तो यह होगा ((अक्षर * 0.50) * 0.75) * 0.90

  • अगर इंटरप्रिटर वास्तव में JIT कंपाइलर है तो 50% की कमी
  • यदि यह किसी भी प्रकार के लूप को अनियंत्रित / सार्थक अनुकूलन पर लागू करता है तो 25% की कमी होती है।
  • अगर आप VM को बढ़ाते हैं तो 10% की कमी होती है
    • BRANCHEQ [कोड लाइन, 4 बाइट्स] (शाखा यदि बराबर - opcode 0x0b)
    • BRANCHGT [कोड लाइन, 4 बाइट्स] (शाखा यदि अधिक से अधिक - opcode 0x0c)
    • BRANCHNE [कोड लाइन, 4 बाइट्स] (यदि नहीं के बराबर शाखा - opcode 0x0d)
    • RLOAD [रजिस्टर 1] [रजिस्टर 2] (रजिस्टर 2 के मूल्य को रजिस्टर करने के लिए 1 - opcode 0x01)।

अनुमति नहीं देना

  • कार्यक्रम में परीक्षण मामले को रोकना निषिद्ध है। आपको या तो STDIN से या एक फ़ाइल से बायटेकोड को स्वीकार करना चाहिए (इससे कोई फर्क नहीं पड़ता)।
  • प्रोग्राम को चलाए बिना आउटपुट लौटना।
  • किसी अन्य तरीके से आप वीएम आवश्यकता को धोखा देने के बारे में सोच सकते हैं।
code-challenge  interpreter  stack 
— रंगीन मोनोक्रोम
स्रोत
क्यों कुछ और परीक्षण कार्यक्रम शामिल नहीं हैं जो आपके द्वारा बताई गई चीजों को हतोत्साहित करने के लिए हैं? यदि यह एक वीएम है, तो यह बाईटेकोड विनिर्देश में लिखित कुछ भी चलाने में सक्षम होना चाहिए, है ना?
— कासरान
मैं आज रात ऐसा करने की कोशिश करूंगा। मैं अभी कंपाइलर लिख रहा हूं।
— रंगीन मोनोक्रोम
संकलक यहाँ है jsfiddle.net/aL9y19bd/23
— मोनोक्रोम
1
CMPकम या समानता के लिए जाँच करता है ? और इसके परिणाम का क्या होता है?
— es1024
1
MULऔर DIVअण्डरपास भी हैं। क्या उन्हें हस्ताक्षरित या अहस्ताक्षरित होना चाहिए? गुणन अतिप्रवाह पर क्या होता है?
— feersum

जवाबों:

8

सी, 752 (परिभाषित झंडे के लिए 589 + 163) * 0.5 (JIT) * 0.9 (एक्सटेंशन) * (0.75 अनुकूलन) * (0.64 सेकंड / 2) = 81.216

C[S],J[S],i,j,k,y,c,X,Y,Z;char*R,a,b[9];main(x){R=mmap(0,S,6,34,-1,0);N=85;while(scanf("%c%s%*[ R]%d%*[ R]%d",&a,b,&x,&y)&&~getchar())a-=65,a-1?a-15?a-9?a?a-2?a-3?a-11?a-12?a-17?(N=41,v):(N=137,v):(N=137,u,N=247,g(H,4),N=139,u):(y?N=189+x,s(y):(N=51,g(G,G))):(N=137,u,N=247,g(H,6),N=139,u):(N=57,v,s(0xFC8A9F),--j):(N=1,v):(N=233,J[k++]=i,s(x)):b[1]-80?N=85+x:(N=93+x):(c=b[5],s(0x0F9EE78A),N=(c-69?c-71?c-76?1:8:11:0)+132,J[k++]=i,s(x)),C[++i]=j;U(E8,X)U(F0,Y)U(F8,Z)s(50013);i=j;while(k--)j=C[J[k]]+1,R[j-1]-233&&(j+=4),s(C[*(int*)(R+j)]-j-4);((int(*)())R)();printf("%u %u %u\n",X,Y,Z);}

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

इसके बाद इसे 80386 बाइटकोड में बदल दिया जाता है और निष्पादित किया जाता है।

लोड हो रहा है 0एक रजिस्टर में ले लेती है xorखुद के साथ रजिस्टर ing बजाय moving0 रजिस्टर, जो तीन बाइट्स उत्पन्न बाईटकोड में कम है में है, और बहुत मामूली तेजी हो सकती है।

संकलन:

gcc -m32 -D"g(a,b)=(N=192|b<<3|a)"-D"s(b)=(*(int*)(R+j)=b,j+=4)"-DN=R[j++]-D"G=((x+1)|4)"
-D"H=((y+1)|4)"-DS=9999-D"u=g(0,G)"-D"v=g(G,H)"-D"U(b,c)=s(0xA3##b##89),--j,s(&c);"
bytecode.c -o bytecode

POSIX- अनुरूप ओएस की आवश्यकता है।

इनपुट STDIN ( ./bytecode < fileफ़ाइल से पाइप का उपयोग) से पढ़ा जाता है ।

परीक्षण कार्यक्रम के लिए परिणाम बायटेकोड: 

; start
 0:   55                      push   %ebp
; LOAD R0 0
 1:   33 ed                   xor    %ebp,%ebp
; LOAD R2 0
 3:   33 ff                   xor    %edi,%edi
; LOAD R1 0
 5:   33 f6                   xor    %esi,%esi
; PUSH $1
 7:   56                      push   %esi
; MUL R1 R2
 8:   89 f0                   mov    %esi,%eax
 a:   f7 e7                   mul    %edi
 c:   8b f0                   mov    %eax,%esi
; PUSH R2
 e:   57                      push   %edi
; LOAD R2 3
 f:   bf 03 00 00 00          mov    $0x3,%edi
; DIV R1 R2
14:   89 f0                   mov    %esi,%eax
16:   f7 f7                   div    %edi
18:   8b f0                   mov    %eax,%esi
; POP R2
1a:   5f                      pop    %edi
; ADD R0 R1
1b:   01 f5                   add    %esi,%ebp
; POP R1
1d:   5e                      pop    %esi
; PUSH R2
1e:   57                      push   %edi
; LOAD R2 1
1f:   bf 01 00 00 00          mov    $0x1,%edi
; ADD R1 R2
24:   01 fe                   add    %edi,%esi
; POP R2
26:   5f                      pop    %edi
; PUSH R2
27:   57                      push   %edi
; LOAD R2 10000
28:   bf 10 27 00 00          mov    $0x2710,%ed
; CMP R1 R2
2d:   39 fe                   cmp    %edi,%esi
2f:   9f                      lahf
30:   8a fc                   mov    %ah,%bh
; POP R2
32:   5f                      pop    %edi
; BRANCHLT 3
33:   8a e7                   mov    %bh,%ah
35:   9e                      sahf
36:   0f 8c cb ff ff ff       jl     0x7
; LOAD R1 1
3c:   be 01 00 00 00          mov    $0x1,%esi
; ADD R2 R1
41:   01 f7                   add    %esi,%edi
; LOAD R1 10000
43:   be 10 27 00 00          mov    $0x2710,%es
; CMP R2 R1
48:   39 f7                   cmp    %esi,%edi
4a:   9f                      lahf
4b:   8a fc                   mov    %ah,%bh
; LOAD R1 0
4d:   33 f6                   xor    %esi,%esi
; BRANCHLT 2
4f:   8a e7                   mov    %bh,%ah
51:   9e                      sahf
52:   0f 8c ad ff ff ff       jl     0x5
; copy R0 to X
58:   89 e8                   mov    %ebp,%eax
5a:   a3 28 5b 42 00          mov    %eax,0x425b
; copy R1 to Y
5f:   89 f0                   mov    %esi,%eax
61:   a3 38 55 44 00          mov    %eax,0x4455
; copy R2 to Z
66:   89 f8                   mov    %edi,%eax
68:   a3 40 55 44 00          mov    %eax,0x4455
; exit
6d:   5d                      pop    %ebp
6e:   c3                      ret

Ungolfed: 

C[9999],J[9999],i,j,k,y,c,X,Y,Z;
char *R,a,b[9];
main(x){
    // 6 is PROC_WRITE|PROC_EXEC
    // 34 is MAP_ANON|MAP_PRIVATE
    R=mmap(0,'~~',6,34,-1,0);

    N=0x55;
    while(scanf("%c%s%*[ R]%d%*[ R]%d",&a,b,&x,&y)&&~getchar())
        a-=65,
        a-1? // B[RANCH**]
            a-15? // P[USH/OP]
                a-9? // J[MP]
                    a? // A[DD]
                        a-2? // C[MP]
                            a-3? // D[IV]
                                a-11? // L[OAD]
                                    a-12? // M[UL]
                                        a-17? // R[LOAD]
                                            // SUB
                                            (N=0x29,g(G,H))
                                        :(N=0x89,g(G,H))
                                    :(N=0x89,g(0,G),N=0xF7,g(H,4),N=0x8B,g(0,G))
                                :(y?N=0xBD+x,s(y):(N=0x33,g(G,G)))
                            :(N=0x89,g(0,G),N=0xF7,g(H,6),N=0x8B,g(0,G))
                        :(N=0x39,g(G,H),s(0xfc8a9f),--j)
                    :(N=0x1,g(G,H))
                :(N=0xE9,J[k++]=i,s(x))
            :b[1]-80? 
                N=0x55+x // PUSH
            :(N=0x5D+x) // POP
        :(c=b[5],s(0x0f9ee78a),N=(
        c-69? // EQ
            c-71? // GT
                c-76? // LT
                    1 // NE
                :8
            :11
        :0
        )+0x84,J[k++]=i,s(x)),
        C[++i]=j
        ;
    // transfer registers to X,Y,Z
    s(0xA3E889),--j,s(&X);
    s(0xA3F089),--j,s(&Y);
    s(0xA3F889),--j,s(&Z);

    // pop and ret
    s(0xC35D);

    i=j;
    // fix distances for jmp/branch**
    while(k--)
        j=C[J[k]]+1,R[j-1]-0xE9&&(j+=4),
        s(C[*(int*)(R+j)]-j-4);

    // call
    ((int(*)())R)();

    // output
    printf("%u %u %u\n",X,Y,Z);
}
— es1024
स्रोत
वाह। काश, मैंने वीएम में कंपाइलर को शामिल करने के लिए एक बोनस जोड़ा होता।
— रंगीन मोनोक्रोम
15 रन से अधिक प्रति सेकंड .67 सेकंड का औसत।
— रंगीन मोनोक्रोम
मुझे असहमत होना होगा कि xoring एक अनुकूलन है। बुद्धिमान कोड आकार के अनुसार, xoring VM की प्रदर्शन विशेषताओं को नहीं बदलता है (मुझे गलत होने पर सही करें)। अनुकूलन से मेरा मतलब था कि इनपुट कोड से निर्देशों को बदल रहा है या हटा रहा है (उदाहरण निरर्थक पीओपी ... PUSH को हटाना) या एक पंक्ति में 2 निर्देशों को महसूस करना रजिस्टर को लोड करता है, इसलिए एक को हटाया जा सकता है, आदि
— रंगीन मोनोक्रोम
संपादित करें: वास्तव में, यह एक अनुकूलन है: यह 15 रन से अधिक प्रति रन 0.64 सेकंड पर गिरा। मुझे लगता है कि यह कोड को छोटा करके (या निरर्थक मेमोरी एक्सेस को हटाकर) कैश कैश या कुछ को रोकता है?
— रंगीन मोनोक्रोम
@ColorfullyMonochrome कुछ आर्किटेक्चर, जब खुद को एक रजिस्टर के xoring के साथ प्रस्तुत किया जाता है, तो वास्तव में निर्देश को निष्पादित नहीं करेगा, लेकिन केवल रजिस्टर को शून्य कर देगा।
— es1024
7

C, स्कोर = 854 बाइट × (~ 0.8 सेकंड / 2) × 0.5 [JIT] × 0.9 [एक्सटेंशन] = ~ 154 बाइट सेकंड

#define G getchar()
#define L for(i=0;i<3;++i)
#define N*(int*)
#define M(x)"P\x8a\xe7\x9e\xf"#x"    KL"
*T[1<<20],**t=T,*F[1<<20],**f=F,R[3],r[]={1,6,7};char*I[]={"L\xb8    GGJH","I\x8b\xc0HHGH","H\x50GG","H\x58GG","I\3\xc0HHGH","I\53\xc0HHGH","M\x8b\xc0\xf7\xe0\x8b\xc0IHLGJ","O\63\xd2\x8b\xc0\xf7\xf0\x8b\xc0IJNGL","L\xe9    KH","L\73\xc0\x9f\x8a\xfcHHGH",M(\x82),M(\x84),M(\x87),M(\x85)},C[1<<24],*c=C;main(i,o,l,g){N c=0xb7ec8b60;c[4]=70;c+=5;while((o=G)>=0){char*s=I[o];l=*s-'G';memcpy(c,s+1,l);for(s+=l+1;o=*s++;){o-='G';if(o<3){g=r[G];c[*s++-'G']|=g<<3*(o&1);if(o>1)c[*s++-'G']|=g<<3;}else{if(o>3)*f++=c+*s-'G';for(i=4;i;--i)c[*s-'G'+i-1]=G;++s;}}*t++=c;c+=l;}*t=c;while(f>F)--f,**f=(int)T[**f]-(int)*f-4;L N&c[7*i]=0x5893e|r[i]<<19,N&c[3+7*i]=R+i;N&c[21]=0xc361e58b;mprotect((int)C>>12<<12,1<<24,7);((void(*)())C)();L printf("R%d %u\n",i,R[i]);}

gcc vm.c -ovm -m32 -wएक x86 POSIX अनुरूप ओएस पर संकलित करें । बाइनरी प्रोग्राम फ़ाइल कहाँ है , इसके
साथ चलाएँ ।./vm < programprogram

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

उदाहरण के लिए, यहाँ परीक्षण कार्यक्रम का अनुवाद है। ecx, esiऔर क्रमशः , और , के ediअनुरूप हैं; स्थिति झंडे रखती है; और खरोंच रजिस्टर हैं; कॉल-स्टैक VM के स्टैक से मेल खाती है:R0R1R2bheaxedx

# Prologue
     0:   60                      pusha
     1:   8b ec                   mov    ebp,esp
     3:   b7 46                   mov    bh,0x46
# LOAD R0 0
     5:   b9 00 00 00 00          mov    ecx,0x0
# LOAD R2 0 <--outer loop value
     a:   bf 00 00 00 00          mov    edi,0x0
# LOAD R1 0 <--inner loop value
     f:   be 00 00 00 00          mov    esi,0x0
#      --Begin inner loop--
# PUSH R1 <--push inner loop value to the stack
    14:   56                      push   esi
# MUL R1 R2 <--(i*j)
    15:   8b c6                   mov    eax,esi
    15:   f7 e7                   mul    edi
    19:   8b f0                   mov    esi,eax
# PUSH R2
    1b:   57                      push   edi
# LOAD R2 3
    1c:   bf 03 00 00 00          mov    edi,0x3
# DIV R1 R2 <-- / 3
    21:   33 d2                   xor    edx,edx
    23:   8b c6                   mov    eax,esi
    25:   f7 f7                   div    edi
    27:   8b f0                   mov    esi,eax
# POP R2
    29:   5f                      pop    edi
# ADD R0 R1 <-- s+=
    2a:   03 ce                   add    ecx,esi
# POP R1
    2c:   5e                      pop    esi
# PUSH R2
    2d:   57                      push   edi
# LOAD R2 1
    2e:   bf 01 00 00 00          mov    edi,0x1
# ADD R1 R2 <--j++
    33:   03 f7                   add    esi,edi
# POP R2
    35:   5f                      pop    edi
# PUSH R2
    36:   57                      push   edi
# LOAD R2 10000
    37:   bf 10 27 00 00          mov    edi,0x2710
# CMP R1 R2 <-- j < 10000
    3c:   3b f7                   cmp    esi,edi
    3e:   9f                      lahf
    3f:   8a fc                   mov    bh,ah
# POP R2
    41:   5f                      pop    edi
# BRANCHLT 4 <--Go back to beginning inner loop
    42:   8a e7                   mov    ah,bh
    44:   9e                      sahf
    45:   0f 82 c9 ff ff ff       jb     0x14
# --Drop To outer loop--
# LOAD R1 1
    4b:   be 01 00 00 00          mov    esi,0x1
# ADD R2 R1 <--i++
    50:   03 fe                   add    edi,esi
# LOAD R1 10000
    52:   be 10 27 00 00          mov    esi,0x2710
# CMP R2 R1 <-- i < 10000
    57:   3b fe                   cmp    edi,esi
    59:   9f                      lahf
    5a:   8a fc                   mov    bh,ah
# LOAD R1 0 <--Reset inner loop
    5c:   be 00 00 00 00          mov    esi,0x0
# BRANCHLT 3
    61:   8a e7                   mov    ah,bh
    63:   9e                      sahf
    64:   0f 82 a5 ff ff ff       jb     0xf
# Epilogue
    6a:   3e 89 0d 60 ac 04 09    mov    DWORD PTR ds:0x904ac60,ecx
    71:   3e 89 35 64 ac 04 09    mov    DWORD PTR ds:0x904ac64,esi
    78:   3e 89 3d 68 ac 04 09    mov    DWORD PTR ds:0x904ac68,edi
    7f:   8b e5                   mov    esp,ebp
    81:   61                      popa
    82:   c3                      ret

Ungolfed

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

— पक्ष
स्रोत
वाह ... मेरी JIT कोड की ~ 900 पंक्तियाँ थी (c ++ में लिखी गई ...)
— रंगीन मोनोक्रोम
15 रनों के लिए प्रति रन 0.63 सेकंड का औसत।
— रंगीन मोनोक्रोम
2

CJam, 222 187 185 बाइट्स * (बहुत धीमी / 2)

मैं बस यह देखना चाहता था कि CJam में इसे लिखकर मैं एक बायटेकोड वीएम को कितना छोटा कर सकता हूं। 200 से कम बाइट्स काफी सभ्य लगते हैं। हालांकि यह बहुत धीमी है, क्योंकि सीजेएम की ही व्याख्या की गई है। परीक्षण कार्यक्रम को चलाने में उम्र लगती है।

304402480 6b:P;q:iD-);{(_P=@/(\L*@@+\}h;]:P;TTT]:R;{_Rf=~}:Q;{4G#%R@0=@t:R;}:O;{TP=("R\(\GG*bt:R;  ~R= R\~@t:R; Q+O Q4G#+-O Q*O Q/O ~(:T; Rf=~-:U; GG*bU0<{(:T}*;"S/=~T):TP,<}g3,{'R\_S\R=N}/

इसे चलाने के लिए, इस स्रोत लिंक पर जावा दुभाषिया डाउनलोड करें , कोड को सहेजें vm.cjamऔर इसके साथ चलाएं

java -jar cjam-0.6.2.jar vm.cjam

कार्यक्रम एसटीडीआईएन पर बायोटेक की उम्मीद करता है। मुझे बाइनरी डेटा को एक प्रोग्राम में पाइप करने का कोई तरीका अभी तक नहीं मिला है, पावरशेल के बिना एक अनुगामी रेखा को तोड़ने और जोड़ने के 0x0aलिए 0x0d 0x0a, जो वास्तव में कष्टप्रद है। कोड को ठीक करने के लिए 4 बाइट्स शामिल हैं (D-); ), जिसे मैंने कुल गिनती में शामिल नहीं किया है, क्योंकि यह कुछ ऐसा नहीं है जो प्रोग्राम को करने की आवश्यकता है अगर यह वास्तव में एसटीडीआईएन पर बाइटकोड प्राप्त करता है, बजाय इसके कुछ अजीब रूप से एन्कोडेड संस्करण के बजाय । अगर किसी को इसके लिए एक तय पता है, तो कृपया मुझे बताएं।

थोड़ा अपराजित:

304402480 6b:P; "Create lookup table for instruction sizes. Store in P.";
q:i             "Read program and convert bytes to integers.";
D-);            "Remove spurious carriage returns. This shouldn't be necessary.";
{(_P=@/(\L*@@+\}h;]:P; "Split into instructions. Store in P.";
"We'll use T for the instruction pointer as it's initialised to 0.";
"Likewise, we'll use U for the CMP flag.";
TTT]:R; "Store [0 0 0] in R for the registers.";
{_Rf=~}:Q; "Register lookup block.";
{4G#%R@0=@t:R;}:O; "Save in register block.";
{TP=("R\(\GG*bt:R;

~R=
R\~@t:R;
Q+O
Q4G#+-O
Q*O
Q/O
~(:T;
Rf=~-:U;
GG*bU0<{(:T}*;"N/=~T):TP,<}g "Run program.";
3,{'R\_S\R=N}/

मैं कल उचित स्पष्टीकरण जोड़ूंगा।

संक्षेप में, मैं सभी रजिस्टरों, इंस्ट्रक्शन पॉइंटर और तुलनात्मक ध्वज को चर में स्टोर कर रहा हूं, ताकि वीजे के स्टैक के रूप में उपयोग करने के लिए सीजाम के स्टैक को मुक्त रख सकूं।

— मार्टिन एंडर
स्रोत
— मार्टिन एंडर
1
20 पुनरावृत्तियों के लिए 15.279 सेकंड का औसत। - 15 परीक्षण। इसका मतलब है कि प्रति परीक्षण 2.12208333 घंटे।
— रंगीन मोनोक्रोम
1

अजगर / सी ++, स्कोर = 56.66

1435 चार्ट * .234 / 2 सेकंड * .5 [JIT] * .75 [अनुकूलन] * .90 [अतिरिक्त वीडियो]

इनपुट प्रोग्राम को c ++ में संकलित करता है, उस पर gcc चलाता है, फिर परिणाम चलाता है। अधिकांश समय gcc के अंदर बिताया जाता है।

एक अनुकूलन जो मैं करता हूं वह स्टैक ऑपरेशन को स्पष्ट चर तक कम करता है यदि इसे शब्दार्थ की अनुमति है। यह बहुत मदद करता है, संकलित कोड के लगभग 10x बेहतर रनटाइम (वास्तव में परिणामी बाइनरी को चलाने के लिए लगभग .056 सेकंड)। मुझे यकीन नहीं है कि जीसीसी क्या कर रहा है जो आपको उस सुधार को प्राप्त करता है, लेकिन यह अच्छा है।

import sys,os
x=map(ord,sys.stdin.read())
w=lambda x:(x[0]<<24)+(x[1]<<16)+(x[2]<<8)+x[3]
I=[]
while x:
 if x[0]==0:f='r%d=%d'%(x[1],w(x[2:]));n=6
 if x[0]==1:f='r%d=r%d'%(x[1],x[2]);n=3
 if x[0]==2:f='P%d'%x[1];n=2
 if x[0]==3:f='O%d'%x[1];n=2
 if x[0]==4:f='r%d=r%d+r%d'%(x[1],x[1],x[2]);n=3
 if x[0]==5:f='r%d=r%d-r%d'%(x[1],x[1],x[2]);n=3
 if x[0]==6:f='r%d=r%d*r%d'%(x[1],x[1],x[2]);n=3
 if x[0]==7:f='r%d=r%d/r%d'%(x[1],x[1],x[2]);n=3
 if x[0]==8:f='goto L%d'%w(x[1:]);n=5
 if x[0]==9:f='a=r%d;b=r%d'%(x[1],x[2]);n=3
 if x[0]==10:f='if(a<b)goto L%d'%w(x[1:]);n=5
 if x[0]==11:f='if(a==b)goto L%d'%w(x[1:]);n=5
 if x[0]==12:f='if(a>b)goto L%d'%w(x[1:]);n=5
 if x[0]==13:f='if(a!=b)goto L%d'%w(x[1:]);n=5
 I+=[f];x=x[n:]
D=[]
d=0
for f in I:D+=[d];d+='P'==f[0];d-='O'==f[0]
J=[]
if all(d==D[int(f[f.find('L')+1:])]for f,d in zip(I,D)if f[0]in'gi'):
 H='uint32_t '+','.join('s%d'%i for i in range(max(D)))+';'
 for f,d in zip(I,D):
  if f[0]=='P':f='s%d=r'%d+f[1:]
  if f[0]=='O':f='r'+f[1:]+'=s%d'%(d-1)
  J+=[f]
else:
 H='std::vector<uint32_t>s;'
 for f,d in zip(I,D):
  if f[0]=='P':f='s.push_back(r'+f[1:]+')'
  if f[0]=='O':f='r'+f[1:]+'=s.back();s.pop_back()'
  J+=[f]
P='#include<vector>\n#include<cstdint>\nuint32_t r0,r1,r2,a,b;'+H+'int main(){'
for i,f in enumerate(J):P+='L%d:'%i+f+';'
P+=r'printf("R0 %u\nR1 %u\nR2 %u\n",r0,r1,r2);}'
c=open("t.cc", "w")
c.write(P)
c.close()
os.system("g++ -O1 t.cc")
os.system("./a.out")

निश्चित रूप से कुछ और गोल्फ हो सकता है।

— कीथ रान्डेल
स्रोत
15 रनों से अधिक प्रति रन .477 सेकंड का औसत।
— रंगीन मोनोक्रोम
1

Lua 5.2 (या LuaJIT), 740 बाइट्स

पहले प्रयास करें, केवल न्यूनतम रूप से गोल्फिंग करें। यह संस्करण काम करता है (कम से कम परीक्षण कार्यक्रम पर), और अतिरिक्त ऑपकोड को लागू करता है, लेकिन अहस्ताक्षरित गणित की आवश्यकता को पूरा नहीं करता है और विशेष रूप से तेज़ नहीं है। एक बोनस के रूप में, हालांकि, यह एक वीएम में एक वीएम चल रहा है, और इस तरह लिखा जाता है कि इसे या तो व्याख्या की जा सकती है (पीयूसी-लुआ के साथ चलाएं) या सॉर्ट-ऑफ-जेआईटी (लुआजिट के साथ चलाएं; अभी भी व्याख्या की गई है, लेकिन इंटरलेटर अब है) JITted)।

संपादित करें: बेहतर गोल्फ, अभी भी बड़ा।

संपादित करें: एक बड़ी त्रुटि तय की, और अब अंकगणित को सीमित करने के लिए प्रतिबंधित करता है unsigned long। किसी तरह आकार को हाथ से बाहर निकलने में कामयाब रहे, हालांकि, लेकिन यह अभी भी गलत जवाब दे रहा है।

संपादित करें: परिणाम सही था, लेकिन आउटपुट नहीं था। के %uबजाय के साथ मुद्रण के लिए बंद कर दिया %dऔर सब कुछ ठीक है। आकार और गति में कुछ हद तक सुधार करने के लिए चर के लिए तालिका-आधारित रजिस्टरों को भी बंद कर दिया ।

EDIT: Lua 5.2 के gotoकथन (LuaJIT में भी उपलब्ध है) का उपयोग करके मैंने दुभाषिया को "JIT-to-Lua" के साथ बदल दिया है, जिससे कोड उत्पन्न होता है जो सीधे Lua VM द्वारा चलाया जाता है। यकीन नहीं होता कि यह वास्तव में जेआईटी के रूप में गिना जाता है, लेकिन यह गति में सुधार करता है।

U,S,P,F=table.unpack,table.insert,table.remove,math.floor X,r0,r1,r2,p,m,s=2^32,0,0,0,1,0,{}C={{'r%u=%u',1,4},{'r%u=r%u',1,1},{'S(s,r%u)',1},{'r%u=P(s)',1},{'r%u=(r%u+r%u)%%X',1,0,1},{'r%u=(r%u-r%u)%%X',1,0,1},{'r%u=(r%u*r%u)%%X',1,0,1},{'r%u=F(r%u/r%u)%%X',1,0,1},{'goto L%u',4},{'m=r%u-r%u',1,1},{'if m<0 then goto L%u end',4},{'if m==0 then goto L%u end',4},{'if m>0 then goto L%u end',4},{'if m~=0 then goto L%u end',4}}t={io.open(arg[1],'rb'):read('*a'):byte(1,-1)}i,n,r=1,0,{}while i<=#t do c,i,x,a=C[t[i]+1],i+1,0,{}for j=2,#c do y=c[j]if y>0 then x=0 for k=1,y do i,x=i+1,x*256+t[i]end end S(a,x)end S(r,('::L%d::'):format(n))n=n+1 S(r,c[1]:format(U(a)))end load(table.concat(r,' '))()print(('R0 %u\nR1 %u\nR2 %u'):format(r0,r1,r2))

यहाँ मूल, पठनीय संस्करण है।

U,S,P,F=table.unpack,table.insert,table.remove,math.floor

X,r0,r1,r2,p,m,s=2^32,0,0,0,1,0,{}

C={
    {'r%u=%u',1,4},
    {'r%u=r%u',1,1},
    {'S(s,r%u)',1},
    {'r%u=P(s)',1},
    {'r%u=(r%u+r%u)%%X',1,0,1},
    {'r%u=(r%u-r%u)%%X',1,0,1},
    {'r%u=(r%u*r%u)%%X',1,0,1},
    {'r%u=F(r%u/r%u)%%X',1,0,1},
    {'goto L%u',4},
    {'m=r%u-r%u',1,1},
    {'if m<0 then goto L%u end',4},
    {'if m==0 then goto L%u end',4},
    {'if m>0 then goto L%u end',4},
    {'if m~=0 then goto L%u end',4},
}

t={io.open(arg[1],'rb'):read('*a'):byte(1,-1)}
i,n,r=1,0,{}
while i<=#t do
    c,i,x,a=C[t[i]+1],i+1,0,{}
    for j=2,#c do
        y=c[j]
        if y>0 then
            x=0 
            for k=1,y do 
                i,x=i+1,x*256+t[i]
            end 
        end
        S(a,x)
    end
    S(r,('::L%d::'):format(n)) 
    n=n+1
    S(r,c[1]:format(U(a)))
end
load(table.concat(r,' '))()
print(('R0 %u\nR1 %u\nR2 %u'):format(r0,r1,r2))
— criptych मोनिका के साथ खड़ा है
स्रोत
जब मैंने आपका प्रोग्राम चलाया, तो मुझे निम्न त्रुटि मिली: pastebin.com/qQBD7Rs8 । क्या आप स्टड पर या फ़ाइल के रूप में बायटेकोड की अपेक्षा करते हैं?
— रंगीन मोनोक्रोम
माफ़ करना। विंडोज़ के लिए मेरा बाइनरी दूषित हो गया था। इस प्रकार, सभी gcc / linux संस्करणों ने काम किया लेकिन विंडोज़ परीक्षण सभी दुर्घटनाग्रस्त हो गए। हालाँकि, यह अभी भी रिपोर्ट कर रहा है कि R0 और R1 0 हैं, जबकि R2 1 है
— रंगीन मोनोक्रोम
मुझे संदेह है कि यह वास्तव में निष्पादित नहीं हो रहा है: औसतन चलने में 33.8 एमएस लिया (जीसीसी को ~ .25 सेकंड)।
— रंगीन मोनोक्रोम
स्क्रिप्ट एक फ़ाइल के रूप में बायटेकोड की अपेक्षा करती है, कमांड लाइन पर फ़ाइल नाम के साथ। हालांकि आप सही हैं, मैंने इसे ट्रेस किया और ऐसा लग रहा है कि यह केवल पहला बाहरी लूप कर रहा है। ड्रॉइंग बोर्ड में वापस ...
— criptych, Monica
यही मुझे सी में सोचने और लुआ में लिखने के लिए मिलता है: मैंने <इसके बजाय अपने छोरों में इस्तेमाल किया <=, इसलिए अंतिम शाखा निर्देश को छोड़ दिया गया। यह अभी भी गलत उत्तर देता है, लेकिन अब इसे करने में कुछ मिनट लगते हैं। :)
— क्रिप्टोकरंसी मोनिका
1

सी#

1505 1475 बाइट्स

यह इंटरप्रेटर का मेरा संस्करण है, जिसे C # में लिखा गया है, मुझे लगता है कि इसे अनुकूलित / और अधिक अनुकूलित किया जा सकता है, लेकिन मुझे वास्तव में यह नहीं पता है कि कहां है);

गोल्फ संस्करण:

using System;using System.Collections.Generic;using System.IO;using System.Linq;class M{static void Main(string[]a){if(a.Length==1&&File.Exists(a[0])){B.E(B.P(File.ReadAllLines(a[0])));Console.WriteLine(B.O);}}}class B{public enum I{L=0x00,P=0x02,Q=0x03,A=0x04,S=0x05,M=0x06,D=0x07,J=0x08,C=0x09,BL=0x0a,BE=0x0b,BG=0x0c,BN=0x0d}public enum R{A,B,C}enum C{N,L,E,G}public static Dictionary<R,uint>r=new Dictionary<R,uint>{{R.A,0},{R.B,0},{R.C,0}};public static Stack<uint>s=new Stack<uint>();static C c=C.N;public static string O{get{return string.Format("R0 {0}\nR1 {1}\nR2 {2}",r[R.A],r[R.B],r[R.C]);}}public static void E(byte[][]l){for(uint i=0;i<l.Length;i++){var q=l[i];switch((I)q[0]){case I.L:r[(R)q[1]]=U(q,2);break;case I.P:r[(R)q[1]]=s.Pop();break;case I.Q:s.Push(r[(R)q[1]]);r[(R)q[1]]=0;break;case I.A:s.Push(r[(R)q[1]]+r[(R)q[2]]);break;case I.S:s.Push(r[(R)q[1]]-r[(R)q[2]]);break;case I.M:s.Push(r[(R)q[1]]*r[(R)q[2]]);break;case I.D:s.Push(r[(R)q[1]]/r[(R)q[2]]);break;case I.J:i=U(q,1)-1;break;case I.C:{uint x=r[(R)q[1]],y=r[(R)q[2]];c=x<y?C.L:x>y?C.G:C.E;}break;case I.BL:if(c==C.L)i=U(q,1)-1;break;case I.BG:if(c==C.G)i=U(q,1)-1;break;case I.BE:if(c==C.E)i=U(q,1)-1;break;case I.BN:if(c!=C.E)i=U(q,1)-1;break;}}}public static byte[][]P(string[]c){return c.Where(l=>!l.StartsWith("#")).Select(r=>r.Split(' ').Where(b=>b.Length>0).Select(b=>Convert.ToByte(b,16)).ToArray()).Where(l=>l.Length>0).ToArray();}static uint U(byte[]b,int i){return(uint)(b[i]<<24|b[i+1]<<16|b[i+2]<<8|b[i+3]);}}

संपादित करें

कुछ अनावश्यक publicऔर privateसंशोधक हटा दिए गए :

using System;using System.Collections.Generic;using System.IO;using System.Linq;class M{static void Main(string[]a){if(a.Length==1&&File.Exists(a[0])){B.E(B.P(File.ReadAllLines(a[0])));Console.Write(B.O);}}}class B{enum I{L=0x00,P=0x02,Q=0x03,A=0x04,S=0x05,M=0x06,D=0x07,J=0x08,C=0x09,BL=0x0a,BE=0x0b,BG=0x0c,BN=0x0d}enum R{A,B,C}enum C{N,L,E,G}static Dictionary<R,uint>r=new Dictionary<R,uint>{{R.A,0},{R.B,0},{R.C,0}};static Stack<uint>s=new Stack<uint>();static C c=C.N;public static string O{get{return string.Format("R0 {0}\nR1 {1}\nR2 {2}\n",r[R.A],r[R.B],r[R.C]);}}public static void E(byte[][]l){for(uint i=0;i<l.Length;i++){var q=l[i];switch((I)q[0]){case I.L:r[(R)q[1]]=U(q,2);break;case I.P:r[(R)q[1]]=s.Pop();break;case I.Q:s.Push(r[(R)q[1]]);r[(R)q[1]]=0;break;case I.A:s.Push(r[(R)q[1]]+r[(R)q[2]]);break;case I.S:s.Push(r[(R)q[1]]-r[(R)q[2]]);break;case I.M:s.Push(r[(R)q[1]]*r[(R)q[2]]);break;case I.D:s.Push(r[(R)q[1]]/r[(R)q[2]]);break;case I.J:i=U(q,1)-1;break;case I.C:{uint x=r[(R)q[1]],y=r[(R)q[2]];c=x<y?C.L:x>y?C.G:C.E;}break;case I.BL:if(c==C.L)i=U(q,1)-1;break;case I.BG:if(c==C.G)i=U(q,1)-1;break;case I.BE:if(c==C.E)i=U(q,1)-1;break;case I.BN:if(c!=C.E)i=U(q,1)-1;break;}}}public static byte[][]P(string[]c){return c.Where(l=>!l.StartsWith("#")).Select(r=>r.Split(' ').Where(b=>b.Length>0).Select(b=>Convert.ToByte(b,16)).ToArray()).Where(l=>l.Length>0).ToArray();}static uint U(byte[]b,int i){return(uint)(b[i]<<24|b[i+1]<<16|b[i+2]<<8|b[i+3]);}}

इसे उस जगह पर कॉल करें executable.exe filenameजहां filenameफ़ाइल की व्याख्या की जाने वाली कोड है

मेरा "परीक्षण कार्यक्रम":

# LOAD R0 5
# CMP R0 R1
# BRANCHEQ 13
# LOAD R1 1
# LOAD R2 1
# CMP R0 R2
# MUL R1 R2
# LOAD R1 1
# ADD R2 R1
# PUSH R2
# PUSH R1 
# BRANCHEQ 13
# JMP 5
# POP R2
# POP R0
# POP R1
# PUSH R0

0x0 0x0 0x0 0x0 0x0 0x5
0x9 0x0 0x1 
0xb 0x0 0x0 0x0 0xd 
0x0 0x1 0x0 0x0 0x0 0x1 
0x0 0x2 0x0 0x0 0x0 0x1 
0x9 0x0 0x2 
0x6 0x1 0x2 
0x0 0x1 0x0 0x0 0x0 0x1 
0x4 0x2 0x1 
0x2 0x2 
0x2 0x1 
0xb 0x0 0x0 0x0 0xd 
0x8 0x0 0x0 0x0 0x5 
0x3 0x2 
0x3 0x0 
0x3 0x1 
0x2 0x0

दुभाषिया अब नाम चर, वर्गों, के साथ ungolfed ...

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        if (args.Length == 1 && File.Exists(args[0]))
        {
            var code = ByteCodeInterpreter.ParseCode(File.ReadAllLines(args[0]));
            ByteCodeInterpreter.Execute(code);
            Console.WriteLine(ByteCodeInterpreter.Output);
        }
    }
}

public static class ByteCodeInterpreter
{
    public enum Instruction : byte
    {
        LOAD = 0x00,
        PUSH = 0x02,
        POP = 0x03,
        ADD = 0x04,
        SUB = 0x05,
        MUL = 0x06,
        DIV = 0x07,
        JMP = 0x08,
        CMP = 0x09,
        BRANCHLT = 0x0a,
        BRANCHEQ = 0x0b,
        BRANCHGT = 0x0c,
        BRANCHNE = 0x0d
    }

    public enum Register : byte
    {
        R0 = 0x00,
        R1 = 0x01,
        R2 = 0x02
    }

    private enum CompareFlag : byte
    {
        NONE = 0x00,
        LT = 0x01,
        EQ = 0x02,
        GT = 0x03,
    }

    public static readonly Dictionary<Register, uint> register = new Dictionary<Register, uint>
    {
        {Register.R0, 0},
        {Register.R1, 0},
        {Register.R2, 0}
    };

    public static readonly Stack<uint> stack = new Stack<uint>();
    private static CompareFlag compareFlag = CompareFlag.NONE;

    public static string Output
    {
        get
        {
            return string.Format("R0 {0}\nR1 {1}\nR2 {2}", register[Register.R0], register[Register.R1],
                register[Register.R2]);
        }
    }

    public static void Execute(byte[][] lines)
    {
        for (uint i = 0; i < lines.Length; i++)
        {
            var line = lines[i];
            switch ((Instruction)line[0])
            {
                case Instruction.LOAD:
                    register[(Register)line[1]] = GetUint(line, 2);
                    break;
                case Instruction.PUSH:
                    register[(Register)line[1]] = stack.Pop();
                    break;
                case Instruction.POP:
                    stack.Push(register[(Register)line[1]]);
                    register[(Register)line[1]] = 0;
                    break;
                case Instruction.ADD:
                    stack.Push(register[(Register)line[1]] + register[(Register)line[2]]);
                    break;
                case Instruction.SUB:
                    stack.Push(register[(Register)line[1]] - register[(Register)line[2]]);
                    break;
                case Instruction.MUL:
                    stack.Push(register[(Register)line[1]] * register[(Register)line[2]]);
                    break;
                case Instruction.DIV:
                    stack.Push(register[(Register)line[1]] / register[(Register)line[2]]);
                    break;
                case Instruction.JMP:
                    i = GetUint(line, 1) - 1;
                    break;
                case Instruction.CMP:
                    {
                        uint v0 = register[(Register)line[1]], v1 = register[(Register)line[2]];
                        if (v0 < v1)
                            compareFlag = CompareFlag.LT;
                        else if (v0 > v1)
                            compareFlag = CompareFlag.GT;
                        else
                            compareFlag = CompareFlag.EQ;
                    }
                    break;
                case Instruction.BRANCHLT:
                    if (compareFlag == CompareFlag.LT)
                        i = GetUint(line, 1) - 1;
                    break;
                case Instruction.BRANCHGT:
                    if (compareFlag == CompareFlag.GT)
                        i = GetUint(line, 1) - 1;
                    break;
                case Instruction.BRANCHEQ:
                    if (compareFlag == CompareFlag.EQ)
                        i = GetUint(line, 1) - 1;
                    break;
                case Instruction.BRANCHNE:
                    if (compareFlag != CompareFlag.EQ)
                        i = GetUint(line, 1) - 1;
                    break;
            }
        }
    }

    public static byte[][] ParseCode(string[] code)
    {
        return
            code.Where(line => !line.StartsWith("#"))
                .Select(line => line.Split(' ').Where(b => b.Length > 0).Select(b => Convert.ToByte(b, 16)).ToArray())
                .Where(line => line.Length > 0)
                .ToArray();
    }

    private static uint GetUint(byte[] bytes, int index)
    {
        return (uint)(bytes[index] << 24 | bytes[index + 1] << 16 | bytes[index + 2] << 8 | bytes[index + 3]);
    }
}
— स्टीफन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.