docs/embedding, docs/java, docs/java-on-truffle, docs/llvm, docs/wasm update ref links to rel paths; start sentences from a new line

Author: olyagpl

docs/reference-manual/embedding/embed-languages.md

@@ -31,7 +31,7 @@ beneath each code example to choose between JavaScript, R, Ruby, and Python.
 Ensure you set up GraalVM before you begin.
 
 ## Compile and Run a Polyglot Application
-GraalVM can run polyglot applications written in any language implemented with the [Truffle language implementation framework](/graalvm-as-a-platform/language-implementation-framework/).
+GraalVM can run polyglot applications written in any language implemented with the [Truffle language implementation framework](../../graalvm-as-a-platform/truffle/README.md).
 These languages are henceforth referenced as **guest languages**.
 
 Complete the steps in this section to create a sample polyglot
@@ -543,12 +543,12 @@ public class Main {
     public static void main(String[] args) {
         try (Context outer = Context.newBuilder()
                                    .allowAllAccess(true)
-                               .build()) {            
+                               .build()) {
             outer.eval("js", "inner = Java.type('org.graalvm.polyglot.Context').create()");
             outer.eval("js", "value = inner.eval('js', '({data:42})')");
             int result = outer.eval("js", "value.data").asInt();
             outer.eval("js", "inner.close()");
-            
+
             System.out.println("Valid " + (result == 42));
         }
     }

docs/reference-manual/embedding/sandbox-options.md

@@ -6,7 +6,7 @@ The following document describes how to configure sandbox resource limits using
 
 In general all resource limit options are prefixed with `sandbox` option group and they can be listed using the help of any language launcher provided in GraalVM e.g. `js --help:tools`.
 Polyglot options can be provided through the language launcher, using the polyglot embedding API of the Graal SDK, or on the JVM using a system property.
-For better understanding of the examples it is recommended to read the [polyglot embedding guide](/reference-manual/embed-languages/) of the reference manual first.
+For better understanding of the examples it is recommended to read the [polyglot embedding guide](embed-languages.md) of the reference manual first.
 
 Currently all sandbox options are experimental therefore in these examples it is assumed that experimental options are enabled (e.g. with `--experimental-options`).
 The options are a best effort approach to limiting resource usage of guest applications.

docs/reference-manual/java-on-truffle/Demos.md

@@ -131,7 +131,7 @@ GraalVM Native Image technology allows compiling applications ahead-of-time (AOT
 The main trade off for using Native Image is that the analysis and compilation of your program happens under the closed world assumption, meaning the static analysis needs to process all bytecode which will ever be executed in the application.
 This makes using some language features like dynamic class loading or reflection tricky.
 
-Java on Truffle is a JVM implementation of a JVM bytecode interpreter, built on the [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/).
+Java on Truffle is a JVM implementation of a JVM bytecode interpreter, built on the [Truffle framework](../../graalvm-as-a-platform/truffle/README.md).
 It is essentially a Java application, as are the Truffle framework itself and the GraalVM JIT compiler.
 All three of them can be compiled ahead-of-time with `native-image`.
 Using Java on Truffle for some parts of your application makes it possible to isolate the required dynamic behaviour and still use the native image on the rest of your code.
@@ -144,9 +144,9 @@ It is a REPL capable of evaluating Java code and consists of two parts:
 This design naturally fits the point we are trying to illustrate. We can build a native executable of the JShell's UI part, and make it include Java on Truffle to run the code dynamically specified at run time.
 
 Prerequisites:
-* [GraalVM 21.0](/downloads/)
-* [Native Image](/reference-manual/native-image/#install-native-image)
-* [Java on Truffle](/reference-manual/java-on-truffle/#install-java-on-truffle)
+* [GraalVM 21.0](https://www.graalvm.org/downloads/)
+* [Native Image](../native-image/README.md/#install-native-image)
+* [Java on Truffle](README.md/#install-java-on-truffle)
 
 
 1. Clone the [project](https://github.com/graalvm/graalvm-demos) with the demo applications and navigate to the `espresso-jshell` directory:

docs/reference-manual/java-on-truffle/FAQ.md

@@ -14,7 +14,7 @@ That means it can only run a Java program once it has been compiled to Java byte
 In the GraalVM family, this is similar to WebAssembly or the LLVM interpreter: while both can run C programs, they have to be complied by a C compiler first.
 
 ### Does Java running on Truffle run on HotSpot too?
-Like other languages implemented with the [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/), it can run both as a native image or on top of HotSpot.
+Like other languages implemented with the [Truffle framework](../../graalvm-as-a-platform/truffle/README.md), it can run both as a native image or on top of HotSpot.
 Running on top of HotSpot is currently only possible on Linux.
 We plan to extend this capability to macOS and Windows platforms also.
 

docs/reference-manual/java-on-truffle/HotSwapPluginAPI.md

@@ -7,7 +7,7 @@ permalink: /reference-manual/java-on-truffle/hotswap-plugin/
 
 # Truffle on Java HotSwap Plugin API
 
-With Java on Truffle you can benefit from enhanced HotSwap [capabilites](/reference-manual/java-on-truffle/demos/#enhanced-hotswap-capabilities-with-java-on-truffle) that allow the code to evolve naturally during development without the need for restarting a running application.
+With Java on Truffle you can benefit from enhanced HotSwap [capabilites](Demos.md/#enhanced-hotswap-capabilities-with-java-on-truffle) that allow the code to evolve naturally during development without the need for restarting a running application.
 ​
 While code reloading (HotSwap) is a powerful tool, it is not sufficient to reflect all kinds of changes, e.g., changes to annotations, framework-specific changes such as implemented services or beans.
 For these things the code often needs to be executed to reload configurations or contexts before the changes are fully reflected in the running instance.
@@ -18,7 +18,7 @@ The main design principle is that you can register various HotSwap listeners tha
 Examples include the ability to re-run a static initializer, a generic post HotSwap callback and hooks when implementations for a certain service provider changes.
 ​
 **Note**: The HotSwap Plugin API is under development and more fine-grained registration of HotSwap listeners are likely to be added upon requests from the community.
-You are welcomed to send enhancement requests to help shape the API through our community support [channels](/community/).
+You are welcomed to send enhancement requests to help shape the API through our community support [channels](https://www.graalvm.org/community/).
 
 Review the HotSwap Plugin API by going through a running example that will enable more powerful reloading support on [Micronaut](https://micronaut.io/).
 ​
@@ -138,7 +138,7 @@ Here is a sample application created from the tutorial ["Creating your first Mic
 Example's sources can be downloaded as a ready-made Gradle project from [here](https://guides.micronaut.io/latest/micronaut-creating-first-graal-app-gradle-java.zip).
 Download, unzip and open the project in your IDE.
 
-Before you proceed, make sure that you have Java on Truffle [installed](/reference-manual/java-on-truffle/#install-java-on-truffle) and set the GraalVM as the project SDK.
+Before you proceed, make sure that you have Java on Truffle [installed](README.md/#install-java-on-truffle) and set the GraalVM as the project SDK.
 ​
 1. In your IDE navigate to the root `build.gradle` within the sample project. Add:
 

docs/reference-manual/java-on-truffle/ImplementationDetails.md

@@ -21,7 +21,7 @@ Java on Truffle is a minified Java VM that implements all core components of a V
 * Java Debug Wire Protocol (JDWP)
 
 Java on Truffle reuses all JARs and native libraries from GraalVM.
-All native libraries and methods are loaded/accessed/called via [Truffle Native Function Interface (JNI)](https://www.graalvm.org/graalvm-as-a-platform/language-implementation-framework/NFI/).
+All native libraries and methods are loaded/accessed/called via [Truffle Native Function Interface (JNI)](../../graalvm-as-a-platform/truffle/NFI.md).
 JNI handles are implemented in Java on Truffle, e.g., all Truffle NFI methods only receive and return primitives.
 Some methods are substituted for performance, e.g., `Math.sqrt`, `System.arraycopy`, avoiding the expensive transition to native.
 
@@ -33,8 +33,8 @@ This mode is not used when running in a native image since there will be no conf
 
 * Java on Truffle does not implement the [JVM Tool Interface (JVMTI)](https://docs.oracle.com/en/java/javase/11/docs/specs/jvmti.html). As a result, it does not support the `-agentlib`, or `-agentpath` VM options.
 * Java on Truffle does not implement the `java.lang.instrument` interface. As a result it does not support the `-javaagent` VM option.
-* Java on Truffle currently uses the standard native libraries from the Java core library. This requires allowing a polyglot `Context` native access. Because of the way these libraries are loaded (via [Truffle NFI](https://www.graalvm.org/graalvm-as-a-platform/language-implementation-framework/NFI/)), running on top of HotSpot only works on Linux (with `glibc`). Running as part of a native image works on Linux, Windows, and macOS but it currently limited to one context.
+* Java on Truffle currently uses the standard native libraries from the Java core library. This requires allowing a polyglot `Context` native access. Because of the way these libraries are loaded (via [Truffle NFI](../../graalvm-as-a-platform/truffle/NFI.md)), running on top of HotSpot only works on Linux (with `glibc`). Running as part of a native image works on Linux, Windows, and macOS but it currently limited to one context.
 * Support for [Java Management Extensions (JMX)](https://docs.oracle.com/javase/tutorial/jmx/index.html) is partial and some methods might return partial data.
-* The [Debugger Protocol Implementation (JDWP)](https://docs.oracle.com/javase/8/docs/technotes/guides/jpda/jdwp-spec.html) lacks some capabilities compared to HotSpot. It will correctly report the supported [capabilities](https://docs.oracle.com/javase/8/docs/platform/jpda/jdwp/jdwp-protocol.html#JDWP_VirtualMachine_Capabilities). In particular actions that require to enumerate all Java objects are not supported. However it does support a few hot reloading cases that HotSpot does not. See [Enhanced HotSwap Capabilities with Java on Truffle](/reference-manual/java-on-truffle/demos/#enhanced-hotswap-capabilities-with-java-on-truffle).
+* The [Debugger Protocol Implementation (JDWP)](https://docs.oracle.com/javase/8/docs/technotes/guides/jpda/jdwp-spec.html) lacks some capabilities compared to HotSpot. It will correctly report the supported [capabilities](https://docs.oracle.com/javase/8/docs/platform/jpda/jdwp/jdwp-protocol.html#JDWP_VirtualMachine_Capabilities). In particular actions that require to enumerate all Java objects are not supported. However it does support a few hot reloading cases that HotSpot does not. See [Enhanced HotSwap Capabilities with Java on Truffle](Demos.md/#enhanced-hotswap-capabilities-with-java-on-truffle).
 * When the `java.MultiThreaded` option is set to "false", [reference processing](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ref/package-summary.html) will not happen. Depending on the application, this could create resource leaks. Note that this option is set to "false" automatically if Java on Truffle runs in a context where a single-threaded language is enabled (e.g., JavaScript).
-* Java on Truffle does not support the [Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) yet. However, it provides a guest Java Polyglot API, described in `polyglot.jar`. For more information, see [Interoperability with Truffle Languages](/reference-manual/java-on-truffle/interoperability/).
+* Java on Truffle does not support the [Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) yet. However, it provides a guest Java Polyglot API, described in `polyglot.jar`. For more information, see [Interoperability with Truffle Languages](Interoperability.md).

docs/reference-manual/java-on-truffle/Interoperability.md

@@ -7,7 +7,7 @@ permalink: /reference-manual/java-on-truffle/interoperability/
 
 # Interoperability with Truffle Languages
 
-Java on Truffle allows you to interface other "Truffle" languages (languages which interpreters are implemented with the [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/)) to create polyglot programs -- programs written in more than one language.
+Java on Truffle allows you to interface other "Truffle" languages (languages which interpreters are implemented with the [Truffle framework](../../graalvm-as-a-platform/truffle/README.md)) to create polyglot programs -- programs written in more than one language.
 
 This guide describes how to load code written in foreign languages, how to export and import objects between languages, how to use Java on Truffle objects from a foreign language, how to use foreign objects from Java on Truffle, and how to embed in host Java.
 

docs/reference-manual/java-on-truffle/README.md

@@ -7,14 +7,14 @@ permalink: /reference-manual/java-on-truffle/
 
 # Java on Truffle
 
-Using GraalVM, you can run Java applications normally [on the JVM](/reference-manual/java/), in [Native Image](/reference-manual/native-image/), and now on Truffle.
+Using GraalVM, you can run Java applications normally [on the JVM](../java/README.md), in [Native Image](../native-image/README.md), and now on Truffle.
 Java on Truffle is an implementation of the Java Virtual Machine Specification, [Java SE 8](https://docs.oracle.com/javase/specs/jvms/se8/html/index.html) and [Java SE 11](https://docs.oracle.com/javase/specs/jvms/se11/html/index.html), built upon GraalVM as a Truffle interpreter.
 It is a minified Java VM that includes all core components of a VM, implements the same API as the Java Runtime Environment library (libjvm.so), and reuses all JARs and native libraries from GraalVM.
-See the [Implementation Details](/reference-manual/java-on-truffle/implementation/) for more information.
+See the [Implementation Details](ImplementationDetails.md) for more information.
 The project name behind this implementation is "Espresso".
 Its open source version is available on [GitHub](https://github.com/oracle/graal/tree/master/espresso).
 
-The Java on Truffle execution mode runs Java via a Java bytecode interpreter, implemented with the [Truffle framework](/graalvm-as-a-platform/language-implementation-framework/) – an open-source library for writing interpreters for programming languages.
+The Java on Truffle execution mode runs Java via a Java bytecode interpreter, implemented with the [Truffle framework](../../graalvm-as-a-platform/truffle/README.md) – an open-source library for writing interpreters for programming languages.
 Now Java can be executed by the same principle as other languages in the GraalVM ecosystem (JavaScript, Ruby, Python, R), directly interoperate with those languages, and pass data back and forth in the same memory space.
 Besides complete language interoperability, with Java on Truffle you can:
 
@@ -28,8 +28,8 @@ It is available as of version 21.0.0.
 
 ## Install Java on Truffle
 
-To run Java on Truffle, you need to have [GraalVM installed](/docs/getting-started/#install-graalvm).
-The Java on Truffle runtime is not available by default, but can be easily added to GraalVM using the [GraalVM Updater tool](/reference-manual/graalvm-updater/).
+To run Java on Truffle, you need to have [GraalVM installed](../../getting-started/graalvm-community/get-started-graalvm-community.md).
+The Java on Truffle runtime is not available by default, but can be easily added to GraalVM using the [GraalVM Updater tool](../graalvm-updater.md).
 
 For GraalVM Community Edition users, run the following command to install Java on Truffle from the GitHub catalog:
 ```shell
@@ -81,7 +81,7 @@ You can still influence the performance by passing the following options to `jav
 * `--engine.MultiTier=true` to enable multi-tier compilation;
 * `--engine.Inlining=false` in combination with `--java.InlineFieldAccessors=true` to make the compilation faster, in exchange for slower performance.
 
-The `--vm.XX:` syntax ensures the option is passed to the underlying [native image VM](https://www.graalvm.org/reference-manual/native-image/HostedvsRuntimeOptions).
+The `--vm.XX:` syntax ensures the option is passed to the underlying [native image VM](../native-image/HostedvsRuntimeOptions.md).
 When using the `-XX:` syntax, the VM first checks if there is such an option in the Java on Truffle runtime.
 If there is none, it will try to apply this option to the underlying native image VM.
 This might be important for options such as `MaxDirectMemorySize` which can be set independently at both levels: `-XX:MaxDirectMemorySize=256M` controls how much native memory can be reserved by the Java program running on Truffle (the guest VM), while `--vm.XX:MaxDirectMemorySize=256M` controls how much native memory can be reserved by native image (the host VM).
@@ -167,11 +167,11 @@ It should show GraalVM as project's JRE and VM options should include `-truffle
 ## What to Read Next
 
 Java on Truffle enables a seamless Java interoperability with other languages in the GraalVM ecosystem.
-Check the [Interoperability with Truffle Languages guide](/reference-manual/java-on-truffle/interoperability/) to learn how to load code written in foreign languages, export and import objects between languages, how to use Java-on-Truffle objects from a foreign language and vice versa to create powerful polyglot programs.
+Check the [Interoperability with Truffle Languages guide](Interoperability.md) to learn how to load code written in foreign languages, export and import objects between languages, how to use Java-on-Truffle objects from a foreign language and vice versa to create powerful polyglot programs.
 
-To learn about the implementation approach, project's current status, and known limitations proceed to [Implementation Details](/reference-manual/java-on-truffle/implementation/).
+To learn about the implementation approach, project's current status, and known limitations proceed to [Implementation Details](ImplementationDetails.md).
 
 You can already run some large applications like the Eclipse IDE, Scala or other languages REPLs, etc. in the Java on Truffle execution mode.
-We recommend having a look at the collection of [Demo Applications](/reference-manual/java-on-truffle/demos/).
+We recommend having a look at the collection of [Demo Applications](Demos.md).
 
-If you have a question, check the available [FAQs](/reference-manual/java-on-truffle/faq/), or reach us directly over the **#espresso** channel in [GraalVM Slack](https://www.graalvm.org/slack-invitation/).
+If you have a question, check the available [FAQs](FAQ.md), or reach us directly over the **#espresso** channel in [GraalVM Slack](https://www.graalvm.org/slack-invitation/).