javacc输入流为其他类的输出

如果你需要将一个 JavaCC 的输入流设置为另一个类的输出流，可以使用 JavaCC 的 `setInputStream()` 方法。这个方法允许你将一个 `java.io.InputStream` 对象设置为 JavaCC 解析器的输入流。你可以将一个输出流包装成输入流，然后将其传递给 JavaCC 的解析器，就像这样：

// 假设你有一个类名为 MyOutputStream，它的输出流可以写入到一个文件中
MyOutputStream outputStream = new MyOutputStream("output.txt");
InputStream inputStream = new InputStream() {
    @Override
    public int read() throws IOException {
        return outputStream.read();
    }
};
MyParser parser = new MyParser(inputStream);

在这个例子中，我们创建了一个名为 `MyOutputStream` 的类，它可以将输出流写入到一个文件中。然后，我们创建了一个匿名的 `java.io.InputStream` 对象，它将 `MyOutputStream` 的输出流包装成输入流。最后，我们将这个输入流传递给 JavaCC 解析器的构造函数中。这样，JavaCC 解析器就会从 `MyOutputStream` 的输出流中读取数据，而不是从标准输入流中读取数据。

相关问题

Javacc输入输出为其他类的输出，如何修改代码

如果您想将 JavaCC 的输入输出更改为其他类的输出，您需要使用 Java 中的 IO 类来实现这个目标。

以下是一个示例代码：

1. 在 JavaCC 语法文件的开头添加以下代码：

import java.io.InputStream;
import java.io.OutputStream;

2. 将 JavaCC 的输入流类型从 java.io.InputStream 更改为其他类的输入流类型，例如：

PARSER_BEGIN(MyParser)
public class MyParser {
  public void parse(MyInputStream input, MyOutputStream output) throws ParseException {
    MyLexer lexer = new MyLexer(input, output);
    // ...
  }
}
PARSER_END(MyParser)

在这个例子中，我们将输入流类型更改为 MyInputStream 类型，并将输出流类型更改为 MyOutputStream 类型。

3. 在解析器中使用新的输入输出流类型，例如：

void MyRule() :
{}
{
  Token tok = <TOKEN>;
  String str = tok.image;
  output.write(str.getBytes());
}

在这个例子中，我们通过 <TOKEN> 获取一个标记，并将其转换为字符串（tok.image）。然后，我们将字符串转换为字节数组，并将其写入 MyOutputStream 中。

通过这些修改，JavaCC 将能够将输入输出转换为其他类的输出。

javacc的输入输出为其他.java文件类的输出，完整代码实例

下面是一个完整的示例代码，演示了如何使用 JavaCC 将输入输出转换为其他 Java 类的输出。在这个示例中，我们将输入从标准输入流更改为从文件读取，并将输出写入到另一个 Java 类的文件中。

1. 创建一个名为 MyInputStream.java 的 Java 类，用于从文件读取输入。示例代码如下：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class MyInputStream extends InputStream {
  private FileInputStream inputStream;

  public MyInputStream(String filePath) throws IOException {
    this.inputStream = new FileInputStream(new File(filePath));
  }

  @Override
  public int read() throws IOException {
    return inputStream.read();
  }
}

这个类继承了 Java 的 InputStream 类，并重写了 read() 方法以从文件中读取输入数据。

2. 创建一个名为 MyOutputStream.java 的 Java 类，用于将输出写入到文件中。示例代码如下：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class MyOutputStream extends OutputStream {
  private FileOutputStream outputStream;

  public MyOutputStream(String filePath) throws IOException {
    this.outputStream = new FileOutputStream(new File(filePath));
  }

  @Override
  public void write(int b) throws IOException {
    outputStream.write(b);
  }
}

这个类继承了 Java 的 OutputStream 类，并重写了 write() 方法以将输出数据写入到文件中。

3. 创建一个名为 MyParser.jj 的 JavaCC 语法文件，并添加以下代码：

import java.io.IOException;

PARSER_BEGIN(MyParser)
import java.io.InputStream;
import java.io.OutputStream;

public class MyParser {
  public void parse(MyInputStream input, MyOutputStream output) throws ParseException, IOException {
    MyLexer lexer = new MyLexer(input, output);
    Token token;
    while ((token = lexer.getNextToken()).kind != 0) {
      String str = token.image;
      output.write(str.getBytes());
    }
    output.close();
  }
}
PARSER_END(MyParser)

SKIP :
{
  " "
| "\t"
| "\r"
| "\n"
}

TOKEN :
{
  <MY_TOKEN: ["a"-"z"]+>
}

void MyRule() :
{}
{
  <MY_TOKEN>
}

这个语法文件定义了一个名为 MyParser 的解析器，并将输入和输出流更改为 MyInputStream 和 MyOutputStream 类型。在解析器中，我们使用 MyLexer 获取下一个标记，将其转换为字符串，然后将其写入 MyOutputStream。

4. 创建一个名为 Main.java 的 Java 类，用于运行解析器并将输出写入文件。示例代码如下：

import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    try {
      MyInputStream input = new MyInputStream("input.txt");
      MyOutputStream output = new MyOutputStream("output.txt");
      MyParser parser = new MyParser();
      parser.parse(input, output);
    } catch (ParseException | IOException e) {
      e.printStackTrace();
    }
  }
}

这个类创建一个 MyInputStream 和 MyOutputStream 对象，并将它们传递给 MyParser 的 parse() 方法以运行解析器并将输出写入文件中。

通过这些修改，JavaCC 将能够将输入输出转换为其他 Java 类的输出。