Programs that reproduces itself

Is it possible to make a Java program that prints its source code to a new file, and compiles开发者_StackOverflow it, and runs the compiled program?

Update:

Okay, might as well make it autorun. Enjoy the madness. Run at your own risk.

Yes it's possible, because I actually wrote it up. It doesn't do the RUN part (that's just too crazy, because as others have mentioned, it will cause an infinite loop), but here it is: Quine.java

import java.io.*;
public class Quine {
   public static void main(String[] args) throws Exception {
      char q = 34;
      String out = "Quine$";
      String text = (
         "import java.io.*; " +
         "public class [OUT] { " +
           "public static void main(String[] args) throws Exception { " +
             "char q = 34; String out = `[OUT]$`; String text = `[TEXT]`; " +
             "PrintWriter pw = new PrintWriter(out + `.java`); " +
             "pw.format(text, 34, out, text); " +
             "pw.close(); Runtime runtime = Runtime.getRuntime(); " +
             "runtime.exec(`javac ` + out + `.java`).waitFor(); " +
             "runtime.exec(`java ` + out); " +
           "} " +
         "}"
      ).replace("`", "%1$c").replace("[OUT]", "%2$s").replace("[TEXT]", "%3$s");
      PrintWriter pw = new PrintWriter(out + ".java");
      pw.format(text, 34, out, text);
      pw.close();
      Runtime runtime = Runtime.getRuntime();
      runtime.exec("javac " + out + ".java").waitFor();
      runtime.exec("java " + out);
   }
}

So here's how to get the craziness to start:

• javac Quine.java to compile
• java Quine to run it
  • It will produce, compile and run Quine$
• I've made sure Quine.java is as readable as possible, so the major difference from Quine$.java are formatting and the 3x replace. The minor difference is that Quine$.java has out set to Quine$$.
• Quine$ will produce, compile and run Quine$$
• Quine$$ will produce, compile and run Quine$$$
• Quine$$$ will produce, compile and run Quine$$$$
• ...

Do note that this doesn't do any reverse-engineering or cheat by reading the .java source code, etc. Quine is a quine-generator because it produces a different code differently formatted, but Quine$ is pretty much a true self-contained quine: it does reproduce itself, it just relabels it Quine$$ (which reproduces itself and relabels to Quine$$$ etc).

So technically there's no infinite loop: it will eventually come to a halt when the file system can't handle another $. I was able to manually stop the madness by forcefully deleting all Quine$* files, but run at your own risk!!!

Yes, it is possible. A trivial implementation would be: have the source code contain itself in a string, save the string to a file and fill its own string with the same string (otherwise, the initial string would be of infinite size, due to the recursive manner of this implementation), compile the file, and run the compiled file (which will, in turn, do the very same).

Non-trivial implementations are significantly harder.

Sure it works - Have a look at rosetta code and navigate to Quine, which is a self-referential program that can, without any external access, output its own source.

There's one example for a quine in Java.

Programs that reproduces itself or Self Replicating Programs are known as Quine Programs

Sample Program in Java which reproduces itself.

public class QuineProgram {

     public static void main(String[] args){
      String f = "public class QuineProgram { "
        + "public static void main(String[] args)"
        + "{ String f =%c%s%1$c;"
        + " System.out.printf(f,34,f);}} ";
      System.out.printf(f, 34, f);
     }

}

Output:

public class QuineProgram { public static void main(String[] args){ String f ="public class QuineProgram { public static void main(String[] args){ String f =%c%s%1$c; System.out.printf(f,34,f);}} "; System.out.printf(f,34,f);}} 

You could use the Java Compiler API (JSR-199) for this. Below, code from the JSR-199 that compiles code from a String (slightly modified to make it compile). The code actually compiles source code from the String into a byte array (i.e. it doesn't write to disk), loads it and then executes it via reflection:

• MemoryFileManager.java: A file manager for compiling strings to byte arrays.
• ByteArrayClassLoader.java: A class loader which loads classes from byte arrays.
• CompileFromString.java: The class that wrap everything together.

That could be a starting point (credits to Peter Van der Ahé, the original author).

BTW, you need of course a JDK to use this API.

I don't know exactly what you want, but I think BeanShell is something you can use. BeanShell is an interpreter. You can run uncompiled Java-code (So you give it a String with code and he runs it).

Of course if you really want to do what you wrote, the machine where the program is running needs a JDK to compile your program.

Hope this helps

I dont think it will work in Java. Wouldn't that involve overwriting a running class file.

Suppose your program is in Quine.java compiled to Quine.class.

Now Quine.class will attempt to write its output to Quine.java (so far so good), and compile it to Quine.class. This is gonna be a problem as Quine.class is already running

Yes - don't forget to use a JDK instead of a JRE:

1. Bundle the app's source code files with the app. The app would copy the source files to a new set of source code files, compile the new source files, bundle the new source code with the new class files into a new app, and then spawn the new app.

   or

2. Bundle a decompiler with the app. The app would run the decompiler on its own class files to generate new source code files, compile the new source files, bundle the decompiler with the new class files into a new app, and then spawn the new app.

Here's a Java Quine using preview text block feature (-source 13 --enable-preview) where output is formatted the same as input:

package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f ="""
package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f =""%c%c%s%1$c"";
    System.out.printf(f, 34, 10, f);
  }
}
""";
    System.out.printf(f, 34, 10, f);
  }
}

Output:

package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f ="""
package org.sample.quine;

public class QuineProgram
{
  public static void main(String...args)
  {
    String f =""%c%c%s%1$c"";
    System.out.printf(f, 34, 10, f);
  }
}
""";
    System.out.printf(f, 34, 10, f);
  }
}

Heavily Commented Version:

package org.sample.quine;

public class Quine
{
  public static void main(String...args)
  {
    // Inside text block use "" followed by token or token followed by "" so that we don't prematurely close text block
    String f ="""
package org.sample.quine;

public class Quine
{
  public static void main(String...args)
  {
    // Inside text block use "" followed by token or token followed by "" so that we don't prematurely close text block
    String f =""%c%c%s%1$c"";
    /* Tokens in template text block, each prefixed with percent symbol
     * 1(c)   third quote (34) of open block delimiter
     * 2(c)   new line    (10) of open block delimiter
     * 3(s)   String f         text block that goes between two text block delimiters
     * 4(1$c) first quote (34) of close block delimiter,
     *        1$ means first argument after template argument
     *        2$ would be second argument after template argument
     */
     // Arguments - 1 template (String f); 2 "; 3 newline; 4 template again without replacing tokens
     System.out.printf(f, 34, 10, f);
  }
}
""";
    /* Tokens in template text block, each prefixed with percent symbol
     * 1(c)   third quote (34) of open block delimiter
     * 2(c)   new line    (10) of open block delimiter
     * 3(s)   String f         text block that goes between two text block delimiters
     * 4(1$c) first quote (34) of close block delimiter,
     *        1$ means first argument after template argument
     *        2$ would be second argument after template argument
     */
    // Arguments - 1 template (String f); 2 "; 3 newline; 4 template again without replacing tokens
    System.out.printf(f, 34, 10, f);
  }
}