1

このコードは、入力、出力、および並べ替えをバブルソートして使用し、それを繰り返すリトルマン コンピューター プログラムです。これはプログラムですが、すべての定数、変数、および分岐先の分岐先の場所にラベルを使用して、コードを簡素化し、読みやすくしたいと考えています。保守性を向上させるためにどのラベル名を使用すればよいかわかりません。数値コードは必要ありません。行番号、ラベル、ニーモニック データ、およびコメントのみ。

000 IN      9001      // input count
001 STO 090 3090 // store count
002 LDA 096 5096 // STO
003 ADD 095 1095 // Determine first location
004 STO 011 3011 // Overwrite STO instruction for list
005 ADD 090 1090
006 STO 092 3092 // Store STO + LOC + Count to determine end
007 LDA 011 5013 // Load manipulated instruction (using as counter)
008 SUB 092 2092 //
009 BRZ 016 7016 // If last count, go to END INPUT LIST
010 IN 9001   
011 DAT 0        // manipulated instruction (store input in list)
012 LDA 011 5011
013 ADD 098 1098 // increment store instruction (to next list location)
014 STO 011 3011 // Update STO instruction
015 BR 007 6007 // GOTO INPUT LIST LOOP
016 LDA 098 5098
017 SUB 090 2090 // 1 – count
018 BRP 061 8061 // GO TO END I LOOP
019 LDA 099 5099
020 STO 092 3092 // set I to zero (0)
021 LDA 090 5090
022 SUB 098 2098 // COUNT - 1
023 SUB 092 1092 // COUNT -1 – I
024 BRZ 061 7061 // if(I == count - 1) GOTO END I LOOP
025 LDA 090 5090
026 SUB 098 2098
027 STO 093 3093 // J = Count – 1
028 LDA 092 5092 // I
029 SUB 093 2093 // I - J
030 BRP 057 8057 // If I == j, then GO END J LOOP
031 LDA 097 5097 // load LDA instruction numeric code
032 ADD 095 1095 // set to LDA 500
033 ADD 093 1093 // set to LDA [500 + j] or A[j]
034 STO 039 3039 // reset instruction
035 SUB 098 2098 // set to LDA [500 + j – 1] or A[j-1]
036 STO 037 3037 // reset instruction
037 DAT 0 // load A[j-1] (instruction is manipulated)
038 STO 088 3088
039 DAT 0 // load A[j] (instruction is manipulated)
040 STO 089 3089
041 SUB 088 2088 // A[j] – A[j-1] (swap if not positive)
042 BRP 053 8053 // GOTO DECREMENT J
043 LDA 096 5096 // load STO instruction code
044 ADD 095 1095 // set to STO 500
045 ADD 093 1093 // set to STO [500 + j]
046 STO 052 3052 // reset instruction
047 SUB 098 2098 // set to STO [500 + j – 1]
048 STO 050 3050 // reset instruction
049 LDA 089 5089 // load A[j]
050 DAT 0 // Store in A[j-1] (instruction is manipulated)
051 LDA 088 5088 // load A[j-1]
052 DAT 0 // Store in A[j] (instruction is manipulated)
053 LDA 093 5093
054 SUB 098 2098
055 STO 093 3093 // J = J – 1
056 BR 028 6028 // GOTO START J LOOP
057 LDA 092 5092
058 ADD 098 1098
059 STO 092 3092 // I = I + 1
060 BR 021 6021 // GOTO START I LOOP
061 LDA 090 5090 // Count
062 OUT 9002
063 LDA 097 5097
064 ADD 095 1095 // LDA + LOC
065 STO 071 3071 // set up instruction
066 ADD 090 1090 // LDA + LOC + Count
067 STO 092 3092 // store unreachable instruction
068 LDA 071 5071 // load manipulated instruction (used as counter)
069 SUB 092 2092
070 BRZ 077 7077 // GOTO END OUTPUT LOOP
071 DAT 0 // manipulated output
072 OUT 9002
073 LDA 071 5071
074 ADD 098 1098
075 STO 071 3071 // increment manipulated instruction
076 BR 068 6028 // GOTO OUTPUT LIST LOOP
077 BR 0 6000 // Branch to top of loop (embedded)
078 HLT 0 // (Should never hit this instruction)
088 DAT 0 // A[j-1] value (also used for swapping)
089 DAT 0 // A[j] value (also used for swapping)
090 DAT 0 // count variable (input and output)
091 DAT 0 // unused
092 DAT 0 // ‘I’ counter
093 DAT 0 // ‘j’ counter
094 DAT 0 // unused
095 DAT 500 // initial list location
096 DAT 3000 // STO instruction
097 DAT 5000 // LDA instruction
098 DAT 1 // one (constant)
099 DAT 0 // zero (constant)
4

1 に答える 1

3

ラベルのインスピレーションとしてコメントを使用してください。どの操作の対象でもない行は、ラベルなしで移動できます。たとえば、次のようになります。

start          IN                  // input count
               STO count           // store count
               LDA stoInstruction  // STO
               ADD location        // Determine first location
               STO storeInput      // Overwrite STO instruction for list
               ADD count 
               STO i               // Store STO + LOC + Count to determine end
loopInput      LDA storeInput      // Load manipulated instruction (using as counter)
               SUB i               //
               BRZ exitInputLoop   // If last count, go to END INPUT LIST
               IN    
storeInput     DAT                 // manipulated instruction (store input in list)
               LDA storeInput 
               ADD one             // increment store instruction (to next list location)
               STO storeInput      // Update STO instruction
               BR loopInput        // GOTO INPUT LIST LOOP
exitInputLoop  LDA one 
               SUB count           // 1 – count
               BRP exitLoopI       // GO TO END I LOOP
               LDA zero 
               STO i               // set I to zero (0)
loopI          LDA count 
               SUB one             // COUNT - 1
               SUB i               // COUNT -1 – I
               BRZ exitLoopI       // if(I == count - 1) GOTO END I LOOP
               LDA count 
               SUB one 
               STO j               // J = Count – 1
loopJ          LDA i               // I
               SUB j               // I - J
               BRP exitLoopJ       // If I == j, then GO END J LOOP
               LDA ldaInstruction  // load LDA instruction numeric code
               ADD location        // set to LDA 500
               ADD j               // set to LDA [500 + j] or A[j]
               STO loadCurrent     // reset instruction
               SUB one             // set to LDA [500 + j – 1] or A[j-1]
               STO loadPrevious    // reset instruction
loadPrevious   DAT                 // load A[j-1] (instruction is manipulated)
               STO previous 
loadCurrent    DAT                 // load A[j] (instruction is manipulated)
               STO current 
               SUB previous        // A[j] – A[j-1] (swap if not positive)
               BRP decrementJ      // GOTO DECREMENT J
               LDA stoInstruction  // load STO instruction code
               ADD location        // set to STO 500
               ADD j               // set to STO [500 + j]
               STO storeCurrent    // reset instruction
               SUB one             // set to STO [500 + j – 1]
               STO storePrevious   // reset instruction
               LDA current         // load A[j]
storePrevious  DAT                 // Store in A[j-1] (instruction is manipulated)
               LDA previous        // load A[j-1]
storeCurrent   DAT                 // Store in A[j] (instruction is manipulated)
decrementJ     LDA j 
               SUB one 
               STO j               // J = J – 1
               BR loopJ            // GOTO START J LOOP
exitLoopJ      LDA i 
               ADD one 
               STO i               // I = I + 1
               BR loopI            // GOTO START I LOOP
exitLoopI      LDA count           // Count
               OUT 
               LDA ldaInstruction
               ADD location        // LDA + LOC
               STO instruction     // set up instruction
               ADD count           // LDA + LOC + Count
               STO i               // store unreachable instruction
loopOutput     LDA instruction     // load manipulated instruction (used as counter)
               SUB i 
               BRZ exitLoopOutput  // GOTO END OUTPUT LOOP
instruction    DAT                 // manipulated output
               OUT 
               LDA instruction 
               ADD one 
               STO instruction     // increment manipulated instruction
               BR loopOutput       // GOTO OUTPUT LIST LOOP
exitLoopOutput BR start            // Branch to top of loop (embedded)
               HLT                 // (Should never hit this instruction)

previous       DAT                 // A[j-1] value (also used for swapping)
current        DAT                 // A[j] value (also used for swapping)
count          DAT                 // count variable (input and output)
               DAT                 // unused
i              DAT                 // ‘I’ counter
j              DAT                 // ‘j’ counter
               DAT                 // unused
location       DAT  500            // initial list location
stoInstruction DAT 3000            // STO instruction
ldaInstruction DAT 5000            // LDA instruction
one            DAT    1            // one (constant)
zero           DAT    0            // zero (constant)

ノート：

  • この LMC は元の LMC の変形で、3 桁の数字がありましたが、4 桁の数字を使用しているようです。

  • コードはあまり簡潔ではありません。入力データに必要なストレージを除いて、98 個のメールボックスを使用しています。少ない枚数でできます。たとえば、75 個のメールボックスを使用するこの実装を見てください。

  • 行番号が必要であると書いていますが、ラベルを使用すると、行番号 (つまり、メールボックス番号) は無関係になります: LMC アセンブラは、アセンブリ中にそれらを割り当てることができます。

標準の 100 メールボックス LMC で実行

コメントの後、標準の LMC に適合したバージョンのコードをここに提供します。これは、実際の入力データ用に残されたスペースがあまりないことを意味します。データ用に 11 個のメールボックスだけが残されます。

以下の部品を交換する必要がありました。

location       DAT  500            // initial list location
stoInstruction DAT 3000            // STO instruction
ldaInstruction DAT 5000            // LDA instruction

...これとともに：

location       DAT list            // initial list location
stoInstruction DAT 300             // STO instruction
ldaInstruction DAT 500             // LDA instruction
list           DAT                 // start of the list

これは、標準の LMC と同様に必要です。

  • オペコードは 4 桁ではなく 3 桁です。
  • メールボックス アドレスは 3 桁ではなく 2 桁です (したがって 500 は受け入れられません)。
  • ハードコードされたメールボックス アドレスではなく、リストの場所として次に利用可能なアドレスを使用することをお勧めします。

また、未使用のメールボックスを定義する 2 行も削除しました。

最後に、前の命令が負の結果を出したときのアキュムレータの値が理論上保証されていないため、2 つのBRZ命令を命令で変更します。その場合、アキュムレータの値は信頼できません (負でない値しか持てないため、ウィキペディアを参照してください)。したがって、未定義の値に対して a を実行すると、リスクが生じます。アキュムレータではなくフラグをチェックするため、安全な命令です。BRPSUBBRZBRP

#input: 3 44 22 99
start          IN                  // input count
               STO count           // store count
               LDA stoInstruction  // STO
               ADD location        // Determine first location
               STO storeInput      // Overwrite STO instruction for list
               ADD count 
               STO i               // Store STO + LOC + Count to determine end
loopInput      LDA storeInput      // Load manipulated instruction (using as counter)
               SUB i               //
               BRP exitInputLoop   // If last count, go to END INPUT LIST
               IN    
storeInput     DAT                 // manipulated instruction (store input in list)
               LDA storeInput 
               ADD one             // increment store instruction (to next list location)
               STO storeInput      // Update STO instruction
               BR loopInput        // GOTO INPUT LIST LOOP
exitInputLoop  LDA one 
               SUB count           // 1 – count
               BRP exitLoopI       // GO TO END I LOOP
               LDA zero 
               STO i               // set I to zero (0)
loopI          LDA count 
               SUB one             // COUNT - 1
               SUB i               // COUNT -1 – I
               BRZ exitLoopI       // if(I == count - 1) GOTO END I LOOP
               LDA count 
               SUB one 
               STO j               // J = Count – 1
loopJ          LDA i               // I
               SUB j               // I - J
               BRP exitLoopJ       // If I == j, then GO END J LOOP
               LDA ldaInstruction  // load LDA instruction numeric code
               ADD location        // set to LDA 500
               ADD j               // set to LDA [500 + j] or A[j]
               STO loadCurrent     // reset instruction
               SUB one             // set to LDA [500 + j – 1] or A[j-1]
               STO loadPrevious    // reset instruction
loadPrevious   DAT                 // load A[j-1] (instruction is manipulated)
               STO previous 
loadCurrent    DAT                 // load A[j] (instruction is manipulated)
               STO current 
               SUB previous        // A[j] – A[j-1] (swap if not positive)
               BRP decrementJ      // GOTO DECREMENT J
               LDA stoInstruction  // load STO instruction code
               ADD location        // set to STO 500
               ADD j               // set to STO [500 + j]
               STO storeCurrent    // reset instruction
               SUB one             // set to STO [500 + j – 1]
               STO storePrevious   // reset instruction
               LDA current         // load A[j]
storePrevious  DAT                 // Store in A[j-1] (instruction is manipulated)
               LDA previous        // load A[j-1]
storeCurrent   DAT                 // Store in A[j] (instruction is manipulated)
decrementJ     LDA j 
               SUB one 
               STO j               // J = J – 1
               BR loopJ            // GOTO START J LOOP
exitLoopJ      LDA i 
               ADD one 
               STO i               // I = I + 1
               BR loopI            // GOTO START I LOOP
exitLoopI      LDA count           // Count
               OUT 
               LDA ldaInstruction
               ADD location        // LDA + LOC
               STO instruction     // set up instruction
               ADD count           // LDA + LOC + Count
               STO i               // store unreachable instruction
loopOutput     LDA instruction     // load manipulated instruction (used as counter)
               SUB i 
               BRP exitLoopOutput  // GOTO END OUTPUT LOOP
instruction    DAT                 // manipulated output
               OUT 
               LDA instruction 
               ADD one 
               STO instruction     // increment manipulated instruction
               BR loopOutput       // GOTO OUTPUT LIST LOOP
exitLoopOutput BR start            // Branch to top of loop (embedded)
               HLT                 // (Should never hit this instruction)

previous       DAT                 // A[j-1] value (also used for swapping)
current        DAT                 // A[j] value (also used for swapping)
count          DAT                 // count variable (input and output)
i              DAT                 // ‘I’ counter
j              DAT                 // ‘j’ counter
location       DAT list            // initial list location
stoInstruction DAT 300             // STO instruction
ldaInstruction DAT 500             // LDA instruction
one            DAT   1             // one (constant)
zero           DAT   0             // zero (constant)
list           DAT

<script src="https://cdn.jsdelivr.net/gh/trincot/lmc@v0.815/lmc.js"></script>

于 2020-11-17T23:19:29.840 に答える