我如何实现循环功能在我的大脑他妈的解释器？

Question

这里已经有很多问题了，但我还是会继续。这是一个简单的脑力操翻译。我想出了所有其他符号，但我不知道如何实现循环。有人能帮忙吗？

package com.lang.bfinterpreter;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;


import com.lang.exceptions.TapeSizeExceededException;


public class Interpreter {

    private Interpreter() {
        super();
    }

    private static String getCode(final String inputFile) throws IOException {
        String code = "";
        
        // store the entire code
        final BufferedReader br = new BufferedReader(new FileReader(inputFile));
        for (String line = br.readLine(); line != null; line = br.readLine()) {
            code += line;
        }
        br.close();

        return code;
    }
    
    public static void interpret(final String inputFile) throws IOException,TapeSizeExceededException,IndexOutOfBoundsException {
        // get the program as a string
        final String code = getCode(inputFile);

        // create the Turing tape (static size)
        Character[] tape = new Character[12000];
        Integer indexPointer = 0;
        for (int i = 0; i != 12000; i++) {
            switch (code.toCharArray()[i]) {
                case ',':
                    tape[indexPointer] = (char) System.in.read();
                    break;
                
                case '.':
                    System.out.println(tape[indexPointer]);
                    break;

                case '+':
                    tape[indexPointer]++;
                    break;

                case '-':
                    tape[indexPointer]--;
                    break;

                case '>':
                    if (indexPointer == 11999) {
                        throw new IndexOutOfBoundsException();
                    }
                    else {
                        indexPointer++;
                    }
                    break;

                case '<':
                    if (indexPointer == 0) {
                        throw new IndexOutOfBoundsException();
                    }
                    else {
                        indexPointer--;
                    }
                    break;
                    
                case '[':
                    // I have a feeling I'll need stack to store nested loops   
                    break;
                    
                    case ']':
                    // I have a feeling I'll need stack to store nested loops   
                    break;
                    
                default:
                    break;
            }
        }

    } 
}

我有一种感觉，我需要使用Stack，但我似乎不知道如何使用。我以前构建过表达式计算器。。。这需要同样的逻辑吗？

Answer 1

我想，最具挑战性的部分是找到匹配的括号。找到匹配括号的位置后，只需检查磁带[indexPointer]的值，然后将i设置到它后面的位置，这应该很容易做到。

给定code中索引i处的一个左括号，要找到与其匹配的右括号，只需转到code中i的右侧即可。你从一个堆栈开始，堆栈中只有一个[——这就是[在i上的[。每当你遇到一个新的[，你就把它推到堆栈上。每当你遇到]时，你从堆栈中弹出一个[——这个]与你弹出的[匹配！当你从堆栈中弹出最后一个[时（即堆栈变空时），你知道你在i处找到了匹配的左括号。

在代码中，您甚至不需要Stack。您可以使用int来编码堆栈中有多少元素-在推送时递增，在弹出时递减。

private static int findMatchingCloseBracketAfterOpenBracket(char[] code, int openBracketIndex) {
    // parameter validations omitted
    int stack = 1;
    for (int i = openBracketIndex + 1; i < code.length ; i++) {
        if (code[i] == '[') {
            stack++;
        } else if (code[i] == ']') {
            stack--;
        }
        if (stack == 0) {
            return i;
        }
    }
    return -1; // brackets not balanced!
}

要找到与之匹配的[，]，方法是一样的，只不过你要走另一个方向，并反转推送和弹出动作。

private static int findMatchingOpenBracketBeforeCloseBracket(char[] code, int closeBracketIndex) {
    // parameter validations omitted
    int stack = 1;
    for (int i = closeBracketIndex - 1; i >= 0 ; i--) {
        if (code[i] == '[') {
            stack--;
        } else if (code[i] == ']') {
            stack++;
        }
        if (stack == 0) {
            return i;
        }
    }
    return -1; // brackets not balanced!
}

（重构这里的代码复制留给读者作为练习）