Fix broken links reported by absolutize.rb script

Author: olyagpl

docs/graalvm-as-a-platform/graalvm-as-a-platform.md

@@ -8,12 +8,12 @@ toc_group: graalvm-as-a-platform
 
 # GraalVM as a Platform
 
-GraalVM is an open ecosystem and allows users to implement a custom language or tool on top of it with the [Truffle language implementation framework](truffle/README.md) which offers APIs for writing interpreters for programming languages in the form of Java programs.
+GraalVM is an open ecosystem and allows users to implement a custom language or tool on top of it with the [Truffle language implementation framework](../../truffle/docs/README.md) which offers APIs for writing interpreters for programming languages in the form of Java programs.
 
 GraalVM loads and runs the Truffle framework, which itself is a Java program -- a collection of JAR files -- together with interpreters.
 These get optimized at runtime into efficient machine code for executing loaded programs.
 
-Learn more about this framework from its [reference documentation](truffle/README.md).
+Learn more about this framework from its [reference documentation](../../truffle/docs/README.md).
 
 ## Implement Your Language
 

docs/graalvm-as-a-platform/implement-instrument.md

@@ -46,7 +46,7 @@ These are [onCreate](https://github.com/graalvm/simpletool/blob/master/src/main/
 The `onCreate` and `onDispose` methods are self-explanatory: they are called by the framework when the instrument is created and disposed.
 We will discuss their implementations later, but first let us discuss the remaining one: `getOptionDescriptors`.
 
-The [Truffle language implementation framework](/graalvm-as-a-platform/language-implementation-framework/) comes with its own system for specifying command-line options.
+The [Truffle language implementation framework](../../truffle/docs/README.md) comes with its own system for specifying command-line options.
 These options allow tool users to control the tool either from the command line or when creating [polyglot contexts](https://www.graalvm.org/truffle/javadoc/org/graalvm/polyglot/Context.html).
 It is annotation-based, and examples for such options are the [ENABLED](https://github.com/graalvm/simpletool/blob/master/src/main/java/com/oracle/truffle/st/SimpleCoverageInstrument.java#L91) and [PRINT_COVERAGE](https://github.com/graalvm/simpletool/blob/master/src/main/java/com/oracle/truffle/st/SimpleCoverageInstrument.java#L97) fields of `SimpleCoverageInstrument`.
 Both of these are static final fields of the type [OptionKey](https://www.graalvm.org/truffle/javadoc/org/graalvm/options/OptionKey.html) annotated with [Option](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/Option.html) which, similar to the `Registration` annotation, provides some metadata for the option.
@@ -128,7 +128,7 @@ As mentioned before, Simple Tool is a Maven project.
 Setting `JAVA_HOME` to a GraalVM installation and running `mvn package` produces a `target/simpletool-<version>.jar`.
 This is the Simple Tool distribution form.
 
-The [Truffle framework](truffle/README.md) offers a clear separation between the language/tooling code and the application code.
+The [Truffle framework](../../truffle/docs/README.md) offers a clear separation between the language/tooling code and the application code.
 For this reason, putting the JAR on the class path will not result in the framework realizing a new tool is needed.
 To achieve this we use `--vm.Dtruffle.class.path.append=/path/to/simpletool-<version>.jar` as is illustrated in a [launcher script for our simple tool](https://github.com/graalvm/simpletool/blob/master/simpletool).
 This script also shows we can [set the CLI options](https://github.com/graalvm/simpletool/blob/master/simpletool#L19) we specified for Simple Tool.

docs/graalvm-as-a-platform/implement-language.md

@@ -11,7 +11,7 @@ toc_group: graalvm-as-a-platform
 We have found that the easiest way to get started with implementing your own language is by extending an existing language such as SimpleLanguage.
 [SimpleLanguage](https://github.com/graalvm/simplelanguage) is a demonstration language built using the [Language API](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/package-summary.html).
 The SimpleLanguage project provides a showcase on how to use the Language APIs for writing your own language.
-It aims to use most of the available [Truffle language implementation framework](truffle/README.md) (henceforth "Truffle") features, and documents their use extensively with inline source documentation.
+It aims to use most of the available [Truffle language implementation framework](../../truffle/docs/README.md) (henceforth "Truffle") features, and documents their use extensively with inline source documentation.
 
 To start, ensure [Maven3](https://maven.apache.org/download.cgi) and GraalVM are available in your system.
 
@@ -48,7 +48,7 @@ The SimpleLanguage demonstration language is licensed under the [Universal Permi
 
 ## IDE Setup
 
-The [Truffle framework](truffle/README.md) provides language-agnostic infrastructure to realize standard IDE features by providing additional APIs.
+The [Truffle framework](../../truffle/docs/README.md) provides language-agnostic infrastructure to realize standard IDE features by providing additional APIs.
 If you would like to experiment with your language and get the benefits of an IDE, consider importing SimpleLanguage as an example.
 
 ### Eclipse
@@ -248,7 +248,7 @@ A sample POM using `--upgrade-module-path` to export Language API packages can b
 
 ### Other JVM Implementations
 
-Unlike GraalVM, which includes all the dependencies needed to run a language implemented with [Truffle](truffle/README.md), other JVM implementations need additional JARs to be present on the class path.
+Unlike GraalVM, which includes all the dependencies needed to run a language implemented with [Truffle](../../truffle/docs/README.md), other JVM implementations need additional JARs to be present on the class path.
 These are the Language API and GraalVM SDK JARs available from Maven Central.
 
 Assuming `JAVA_HOME` points to a stock JDK installation, and that the current working directory is the `simplelanguage` directory and the Language API and GraalVM SDK JARs are present in that directory, one can execute SimpleLanguage with the following command:

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)](../../graalvm-as-a-platform/truffle/NFI.md).
+All native libraries and methods are loaded/accessed/called via [Truffle Native Function Interface (JNI)](../../../truffle/docs/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,7 +33,7 @@ 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](../../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.
+* 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](../../../truffle/docs/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](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).

docs/reference-manual/polyglot-programming.md

@@ -14,7 +14,7 @@ permalink: /reference-manual/polyglot-programming/
 * [Passing Options Programmatically](#passing-options-programmatically)
 * [Passing Options Using JVM Arguments](#passing-options-using-jvm-arguments)
 
-GraalVM allows users to write polyglot applications that seamlessly pass values from one language to another by means of the [Truffle language implementation framework](../../../truffle/docs/README.md) (henceforth "Truffle").
+GraalVM allows users to write polyglot applications that seamlessly pass values from one language to another by means of the [Truffle language implementation framework](../../truffle/docs/README.md) (henceforth "Truffle").
 
 Truffle is a Java library for building programming languages implementations as interpreters for self-modifying Abstract Syntax Trees.
 When writing a language interpreter with Truffle, it will automatically use the GraalVM compiler as a just-in-time compiler for the language.