[m-rev.] for review: Delete references to Erlang backend in documentation.
Peter Wang
novalazy at gmail.com
Mon Oct 26 17:09:18 AEDT 2020
.INSTALL.in:
.nocopyright:
BUGS:
README.Erlang:
README.MS-VisualC:
README.MacOS:
README.MinGW:
README.md:
doc/reference_manual.texi:
doc/user_guide.texi:
As above.
NEWS:
Announce removal of Erlang backend.
---
.INSTALL.in | 4 -
.nocopyright | 1 -
BUGS | 4 +-
NEWS | 2 +
README.Erlang | 260 --------------------------------------
README.MS-VisualC | 4 +-
README.MacOS | 7 +-
README.MinGW | 9 --
README.md | 1 -
doc/reference_manual.texi | 243 +----------------------------------
doc/user_guide.texi | 157 ++---------------------
11 files changed, 29 insertions(+), 663 deletions(-)
delete mode 100644 README.Erlang
diff --git a/.INSTALL.in b/.INSTALL.in
index 893ad6457..2711d58ea 100755
--- a/.INSTALL.in
+++ b/.INSTALL.in
@@ -177,10 +177,6 @@ make install
# C# grade. The C# grade will be installed by default if the
# .NET SDK is found.
#
-# The option --enable-erlang-grade causes the installation of the
-# Erlang grade. This grade is only installed if the Erlang/OTP
-# distribution is found.
-#
# The option --enable-ssdebug-grades adds source-to-source debugging
# grades hlc.gc.ssdebug and java.ssdebug, if hlc.gc or java grades
# are also present.
diff --git a/.nocopyright b/.nocopyright
index 251da11f1..85cb0266b 100644
--- a/.nocopyright
+++ b/.nocopyright
@@ -18,7 +18,6 @@ README.AIX
README.BSDI
README.DotNet
README.Cygwin
-README.Erlang
README.FreeBSD
README.HPUX
README.IRIX-5
diff --git a/BUGS b/BUGS
index 56a565aac..34fd79b7d 100644
--- a/BUGS
+++ b/BUGS
@@ -19,8 +19,8 @@ Please include the following information in your bug report:
* the command line flags with which the Mercury compiler was invoked;
* the name and version of the C compiler that you are using;
-For bugs that involve the Erlang, Java or C# backends, include the name and
-version of the Erlang, Java or C# implementation that you are using.
+For bugs that involve the Java or C# backends, include the name and
+version of the Java or C# implementation that you are using.
Please try to ensure that bug report contains all the information that we need to
be able to reproduce the problem. Make sure that all bug reports are fully
diff --git a/NEWS b/NEWS
index 24d083b14..abde17870 100644
--- a/NEWS
+++ b/NEWS
@@ -13,6 +13,8 @@ Changes that may break compatibility
* We have dropped support for macOS 10.8 and earlier.
+* We have removed the Erlang backend as it was unmaintained.
+
Changes to the Mercury standard library
---------------------------------------
diff --git a/README.Erlang b/README.Erlang
deleted file mode 100644
index 31e2cac88..000000000
--- a/README.Erlang
+++ /dev/null
[snip]
diff --git a/README.MS-VisualC b/README.MS-VisualC
index b1672f722..638ebb5ab 100644
--- a/README.MS-VisualC
+++ b/README.MS-VisualC
@@ -48,8 +48,8 @@ returned by autoconf match '*mingw*'; in particular it must *not* match
'*-pc-msys'. You can use the config.guess script to see what configuration
type autoconf detects.
-In order to install the C#, Erlang or Java grades you will require a C#,
-Erlang or Java compiler to be included in the Windows PATH.
+In order to install the C# or Java grades you will require a C# or Java
+compiler to be included in the Windows PATH.
(See the relevant README files for further details, e.g. README.Java etc)
Note that boehm_gc/NT_MAKEFILE supports both i386 and x64 architectures,
diff --git a/README.MacOS b/README.MacOS
index f5771649a..f3e080605 100644
--- a/README.MacOS
+++ b/README.MacOS
@@ -24,10 +24,9 @@ The `asm_fast*` and `reg*` grades are only available on 64-bit Intel systems
and only when using GCC version 4.3 or later as the C compiler.
If `clang` is being used as the C compiler then the only low-level C grades
-available are the `none*` grades. The high-level C, Java, Erlang and C# grades
-all work. The `erlang` grade requires an Erlang installation to be available
-and the C# grades require the Mono .NET implementation. (See README.Erlang and
-README.CSharp for further details.)
+available are the `none*` grades. The high-level C, Java and C# grades
+all work. The C# grades require the Mono .NET implementation.
+(See README.CSharp for further details.)
If the `asm_fast.gc` grade is not available, and unless otherwise directed,
then the `hlc.gc` grade will be used as the default grade for compiling
diff --git a/README.MinGW b/README.MinGW
index 85b76ca9b..a377fa957 100644
--- a/README.MinGW
+++ b/README.MinGW
@@ -86,15 +86,6 @@ To build the source distribution under MSYS follow these steps:
See README.CSharp for further details.
- Optional: To build the Erlang grade with MinGW and MSYS / MSYS2 you will
- require the Windows version of the Erlang/OTP distribution to be installed
- on your system. The Erlang compiler (erlc) and runtime (erl) needs to be
- in your PATH, for example do the following in the shell:
-
- export PATH=/c/Program\ Files/erl5.8.2/bin/:$PATH
-
- See README.Erlang for further details.
-
3. Unpack the source distribution with a command like:
tar -xvzf mercury-compiler-<VERSION>.tar.gz
diff --git a/README.md b/README.md
index 51df0c343..e2722a131 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,6 @@ Specific information is contained in individual README files:
* C
* [C#](README.CSharp)
- * [Erlang](README.Erlang)
* [Java](README.Java)
* Platforms
diff --git a/doc/reference_manual.texi b/doc/reference_manual.texi
index c30fa3e75..551908334 100644
--- a/doc/reference_manual.texi
+++ b/doc/reference_manual.texi
@@ -2188,7 +2188,7 @@ The choice between the two encodings is implementation dependent.
In the Melbourne Mercury implementation,
@code{string}s are represented
-using UTF-8 when generating code for C or Erlang,
+using UTF-8 when generating code for C,
and using UTF-16 when generating code for C# or Java.
@node Other builtin types
@@ -2867,10 +2867,9 @@ For the primitive type @code{string},
the standard ordering is implementation dependent.
The current implementation performs string comparison using
the C @code{strcmp()} function,
-the Java @code{String.compareTo()} method,
-the C# @code{System.String.CompareOrdinal()} method, and
-the Erlang term comparison operators,
-when compiling to C, Java, C# and Erlang respectively.
+the Java @code{String.compareTo()} method, and
+the C# @code{System.String.CompareOrdinal()} method,
+when compiling to C, Java and C# respectively.
For tuple types, corresponding arguments are compared,
with the first argument being the most significant,
@@ -7660,7 +7659,6 @@ to the foreign language's parameter passing convention.
* C data passing conventions ::
* C# data passing conventions ::
* Java data passing conventions ::
-* Erlang data passing conventions ::
@end menu
@node C data passing conventions
@@ -8067,65 +8065,6 @@ List_1<E> list.empty_list() // create an empty list
// the given head and tail
@end example
- at node Erlang data passing conventions
- at subsection Erlang data passing conventions
-
-The Mercury types @code{int}, @code{float} and @code{char}
-are mapped to Erlang integers, floats and integers respectively.
-A Mercury @code{string} is represented by an Erlang binary,
-not by a list of integers.
-
-Mercury variables whose type is a Mercury discriminated union type
-will be passed as an Erlang tuple,
-with the first element of the tuple
-being an Erlang atom named after the Mercury data constructor.
-For example, values of the type:
-
- at example
-:- type maybe_int
- ---> yes(int)
- ; no.
- at end example
-
- at noindent
-would be represented in Erlang
-as @samp{@{yes, @var{integer}@}} and @samp{@{no@}}.
-
-Mercury variables whose type is a Mercury equivalence type will be passed
-as the representation of the right hand side of the equivalence type.
-
-This mapping is subject to change and you should try to avoid writing code
-that relies heavily upon a particular representation of Mercury terms.
-
-Arguments of dummy types, e.g. @samp{io.state},
-are represented by the atom @samp{false} when necessary.
-They are not passed to and from calls to monomorphic procedures.
-
-Mercury arguments declared with input modes
-are passed by value to the corresponding Erlang function.
-
-The result of an Erlang function
-depends on the determinism of the Mercury procedure that it was derived from.
-Procedures which succeed exactly once and have a single output variable
-return the single value directly.
-Procedures which succeed exactly once
-and have zero or two or more output variables
-return a tuple of those output variables in order.
-
-Procedures which are semideterministic return, on success,
-a tuple of the variables with output modes
-(including when the number of output variables is one).
-On failure they return the Erlang atom @samp{fail}.
-
-Procedures which are nondeterministic
-take as a final argument a success continuation.
-This is an function which has an input variable
-for each variable of the Mercury procedure with an output mode.
-For each solution, the success continuation is called
-with the values of those output variables.
-When there are no more solutions,
-the Erlang function returns with an undefined value.
-
@c -----------------------------------------------------------------------
@node Using foreign types from Mercury
@@ -8512,8 +8451,8 @@ you can use the following variant of the declaration:
:- pragma foreign_decl("@var{Lang}", local, @var{DeclCode}).
@end example
-Note: currently only the C and Erlang backends
-support this variant of the @samp{pragma foreign_decl} declaration.
+Note: currently only the C backend
+supports this variant of the @samp{pragma foreign_decl} declaration.
The Melbourne Mercury implementation additionally supports the forms
@@ -8661,7 +8600,6 @@ as dependencies of the module.
* Interfacing with C :: How to write code to interface with C
* Interfacing with C# :: How to write code to interface with C#
* Interfacing with Java :: How to write code to interface with Java
-* Interfacing with Erlang :: How to write code to interface with Erlang
@end menu
All Mercury implementations should support interfacing with C.
@@ -8685,9 +8623,6 @@ Use the string @code{"C#"} to set the foreign language to C#.
@item @samp{Java}
Use the string @code{"Java"} to set the foreign language to Java.
- at item @samp{Erlang}
-Use the string @code{"Erlang"} to set the foreign language to Erlang.
-
@end table
@c -----------------------------------------------------------------------
@@ -9572,166 +9507,6 @@ For example:
@c ----------------------------------------------------------------------------
- at node Interfacing with Erlang
- at subsection Interfacing with Erlang
-
- at menu
-* Using pragma foreign_type for Erlang :: Declaring Erlang types in Mercury
-* Using pragma foreign_export_enum for Erlang :: Using Mercury enumerations in
- Erlang
-* Using pragma foreign_proc for Erlang :: Calling Erlang code from Mercury
-* Using pragma foreign_export for Erlang :: Calling Mercury from Erlang code
-* Using pragma foreign_decl for Erlang :: Including Erlang declarations in Mercury
-* Using pragma foreign_code for Erlang :: Including Erlang code in Mercury
- at end menu
-
-
- at node Using pragma foreign_type for Erlang
- at subsubsection Using pragma foreign_type for Erlang
-
-An Erlang @samp{pragma foreign_type} declaration has the form:
-
- at example
-:- pragma foreign_type("Erlang", @var{MercuryTypeName}, "").
- at end example
-
-The effect of this declaration is that
-Mercury values of type @var{MercuryTypeName}
-will be passed to and from Erlang foreign_procs
-as having some representation unknown to Mercury.
-
- at node Using pragma foreign_export_enum for Erlang
- at subsubsection Using pragma foreign_export_enum for Erlang
-
-Values of Mercury enumeration types may be referred to from Erlang code
-using the convention for discriminated union types
-described in @ref{Erlang data passing conventions}.
-As such, @samp{pragma foreign_export_enum} declarations
-are neither required or supported for Erlang.
-
- at node Using pragma foreign_proc for Erlang
- at subsubsection Using pragma foreign_proc for Erlang
-
-The input and output variables for a Erlang @samp{pragma foreign_proc}
-will be the Erlang representations
-as described in @ref{Erlang data passing conventions}.
-
-The Erlang code in a @code{pragma foreign_proc} declaration
-for a procedure whose determinism indicates that it can fail
-must assign either @samp{true} or @samp{false}
-to the variable @code{SUCCESS_INDICATOR}.
-For example:
-
- at example
-:- pred contains_char(list(char)::in, char::in) is semidet.
-
-:- pragma foreign_proc("Erlang",
- contains_char(Str::in, Ch::in),
- [will_not_call_mercury, promise_pure, thread_safe],
-"
- SUCCESS_INDICATOR = (string:chr(Str, Ch) =/= 0)
-").
- at end example
-
-Arguments whose mode is input
-will have their values set by the Mercury implementation
-on entry to the Erlang code.
-The Erlang code must set the values of all output variables,
-even if the procedure fails
-(i.e. sets the @code{SUCCESS_INDICATOR} variable to @code{false}).
-
- at node Using pragma foreign_export for Erlang
- at subsubsection Using pragma foreign_export for Erlang
-
-A @samp{pragma foreign_export} declaration for Erlang has the form:
-
- at example
-:- pragma foreign_export("Erlang", @var{MercuryMode}, "@var{Erlang_Name}").
- at end example
-
-For example,
-
- at example
-:- pragma foreign_export("Erlang", foo(in, in, out), "foo").
- at end example
-
-The type signature of the Erlang interface to a Mercury procedure
-is described in @ref{Erlang data passing conventions}.
-
-Calling polymorphically typed Mercury procedures from Erlang
-is a little bit more difficult
-than calling ordinary (monomorphically typed) Mercury procedures.
-The simplest method is to just create monomorphic forwarding procedures
-that call the polymorphic procedures, and export them,
-rather than exporting the polymorphic procedures.
-
-If you do export a polymorphically typed Mercury procedure,
-the compiler will prepend one @samp{type_info} argument
-to the parameter list of the Erlang interface function
-for each distinct type variable in the Mercury procedure's type signature.
-The caller must arrange to pass in appropriate @samp{type_info} values
-corresponding to the types of the other arguments passed.
-These @samp{type_info} arguments can be obtained
-using the Mercury @samp{type_of} function
-in the Mercury standard library module @samp{type_desc}.
-
- at node Using pragma foreign_decl for Erlang
- at subsubsection Using pragma foreign_decl for Erlang
-
- at samp{pragma foreign_decl} declarations for Erlang
-can be used to provide any top-level Erlang declarations
-(e.g.@: @samp{-define} macro declarations) which are needed by Erlang code.
-
- at samp{pragma foreign_decl} blocks
-which do not have the @samp{local} attribute
-will be copied into the @samp{.hrl} header file for that module,
-and automatically included by other modules that import the module.
-Therefore @samp{-export} directives and Erlang module attributes
-should only appear in @samp{local} blocks.
-
-For example:
-
- at example
-:- pragma foreign_decl("Erlang", "
- -define(FOO, 42).
-").
-:- pred hello(io.state::di, io.state::uo) is det.
-:- pragma foreign_proc("Erlang",
- hello(_IO0::di, _IO::uo),
- [will_not_call_mercury, promise_pure],
-"
- io:format(""FOO = ~w~n"", [?FOO])
-").
- at end example
-
- at node Using pragma foreign_code for Erlang
- at subsubsection Using pragma foreign_code for Erlang
-
- at samp{pragma foreign_code} can be used to define additional Erlang functions
-which can then be referenced by @samp{pragma foreign_proc} declarations
-for Erlang from that module.
-By adding @samp{-export} directives
-inside @samp{pragma foreign_decl} declarations,
-those functions can additionally be called from outside the defining module.
-
-For example:
-
- at example
-:- pragma foreign_code("Erlang", "
- foo() -> io:put_chars(""Foo."").
-").
-
-:- impure pred say_foo is det.
-:- pragma foreign_proc("Erlang",
- say_foo,
- [will_not_call_mercury],
-"
- foo()
-").
- at end example
-
- at c ----------------------------------------------------------------------------
-
@node Impurity
@chapter Impurity declarations
@@ -10577,8 +10352,6 @@ True if the target language of the compilation is C.
True if the target language of the compilation is C#.
@item @samp{java}
True if the target language of the compilation is Java.
- at item @samp{erlang}
-True if the target language of the compilation is Erlang.
@end table
@c (We may support the specification of other kinds of grades in the future.)
@@ -11193,7 +10966,7 @@ the current Mercury implementation supports
three different pragmas for tabling, to cover these three cases:
@samp{loop_check}, @samp{memo}, and @samp{minimal_model}.
(None of these are supported
-when targeting the generation of C#, Java, or Erlang code.)
+when targeting the generation of C# or Java code.)
@itemize @bullet
@item
@@ -11731,8 +11504,6 @@ then the compiler will quit with an error message.
@c non-recursive.
@c
@c This pragma has no effect with @samp{--no-optimize-tailcalls}.
- at c It also has no effect when generating Erlang code,
- at c because the Erlang implementation itself implements last call optimisation.
@c
@c Issuing the pragma more than once for the same predicate or function, or a
@c mode off that predicate or function, will cause undefined behaviour.
diff --git a/doc/user_guide.texi b/doc/user_guide.texi
index 34171077e..30a407a3c 100644
--- a/doc/user_guide.texi
+++ b/doc/user_guide.texi
@@ -151,7 +151,7 @@ that uses a web interface.
@end itemize
Mercury programs can be compiled to executables
-via any one of four target languages: C, Java, C#, and Erlang.
+via any one of three target languages: C, Java and C#.
The most frequently used target language is C, for two main reasons.
The first is that several important parts of the Mercury system,
such as @samp{mdb}, @samp{mprof} and @samp{mdprof},
@@ -249,11 +249,6 @@ to avoid conflicts with system header files.
@file{.dll} files are library assemblies and,
when compiling to C#, @file{.exe} files are process assemblies.
- at file{.erl} files are Erlang source code, and
- at file{.beam} files are Erlang bytecode (object) files.
- at file{.beams} directories are collections of @file{.beam} files,
-and as such they act like a library archive.
-
When smart recompilation (@pxref{Auxiliary output options}) is enabled,
@file{.c_date}, @file{.cs_date}, @file{.java_date} and @file{.erl_date} files
perform the same function for
@@ -356,15 +351,6 @@ that invokes the program using the Java interpreter.
Otherwise, it will generate a shell script called @file{@var{filename}}
that also invokes the program using the Java interpreter.
-When targeting Erlang,
- at samp{mmc} will place all of the object files for the executable
-into the subdirectory @file{Mercury/beams}.
-If you are using the Windows command line interpreter @samp{cmd.exe},
- at samp{mmc} will generate a batch file called @file{@var{filename}.bat}
-that starts the Erlang runtime system and runs the program.
-Otherwise, it will generate a shell script named @file{@var{filename}}
-that also starts the Erlang runtime system and runs the program.
-
If you use Mmake or @samp{mmc --make},
then you do not need to understand the details
of how the Mercury implementation goes about building programs.
@@ -510,7 +496,7 @@ The most useful of these are the options that set the size of the stacks.
(For the full list of available options, see @ref{Environment}.)
@c XXX FIXME This is wrong for the case when --high-level-code is enabled.
-When targeting Java, C# or Erlang,
+When targeting Java or C#,
and when targeting high level C (@samp{mmc --high-level-code}),
stack management is the responsibility of the target language's compiler.
When targeting low level C (@samp{mmc} without --high-level code),
@@ -774,11 +760,6 @@ Options to pass to the C compiler.
@vindex EXTRA_JAVACFLAGS
Options to pass to the Java compiler (if you are using it).
- at item ERLANG_FLAGS and EXTRA_ERLANG_FLAGS
- at vindex ERLANG_FLAGS
- at vindex EXTRA_ERLANG_FLAGS
-Options to pass to the Erlang compiler (if you are using it).
-
@item ML
@vindex ML
The executable that invokes the linker.
@@ -1041,7 +1022,6 @@ and, on many platforms, it supports shared object libraries.
* Building with Mmake::
* Libraries and the Java grade::
* Libraries and the C# grade::
-* Libraries and the Erlang grade::
@end menu
@node Writing libraries
@@ -1449,19 +1429,6 @@ Mmake does @emph{not} support C# targets.
Libraries are complied to a dynamic link library assembly whose name has the
form @file{@var{library-name}.dll}.
- at node Libraries and the Erlang grade
- at section Libraries and the Erlang grade
- at cindex .beams directories
- at cindex Erlang libraries
-
-Since the Erlang implementation does not have library files, the Mercury
-compiler puts all the @file{.beam} files for a single Mercury library into a
-directory named @file{lib at var{library-name}.beams}.
-
-To create or install an Erlang "library", specify that you want to use
-the erlang grade and use @samp{mmc --make}.
-Mmake does @emph{not} support Erlang targets.
-
@c ----------------------------------------------------------------------------
@node Debugging
@@ -7310,8 +7277,7 @@ Check the module for errors, but do not generate any code.
@findex --target-code-only
Generate target code (i.e.@: C in @file{@var{module}.c},
C# in @file{@var{module}.cs},
-Java in @file{@var{module}.java}
-or Erlang in @file{@var{module}.erl}),
+or Java in @file{@var{module}.java},
but not object code.
@sp 1
@@ -7993,7 +7959,6 @@ in which the first element is a @samp{base grade},
and each following element (if any) is a @samp{grade modifier}.
@cindex csharp (compilation grade)
- at cindex erlang (compilation grade)
@cindex java (compilation grade)
@cindex hlc (compilation grade)
@@ -8008,7 +7973,7 @@ and if the compiler can do this in several different ways,
selects one of those ways.
The available base grades are the following.
- at c What target language to use (C, C#, Java or Erlang),
+ at c What target language to use (C, C# or Java),
@c for C, whether to generate idiomatic C or assembly-like code,
@c and if the latter, what combination of GNU C extensions to use.
@c The options are
@@ -8046,10 +8011,6 @@ This base grade calls for generating C#.
@item @samp{java}
This base grade calls for generating Java.
-
- at item @samp{erlang}
-This base grade calls for generating Erlang.
-Note that support for generating Erlang is experimental.
@end table
The default base grade is system dependent,
@@ -8088,7 +8049,7 @@ and not all grade modifiers are compatible with each other.
@table @asis
@item garbage collection
The default is no garbage collection beyond what the target language provides.
-C#, Java and Erlang have their own builtin garbage collectors, but C does not.
+C# and Java have their own builtin garbage collectors, but C does not.
Since garbage collection is essential for all programs
other than those with @emph{very} short runtimes,
base grades that target C
@@ -8217,7 +8178,6 @@ and grade modifier; they are followed by descriptions of those options.
@findex --target
@findex --csharp
@findex --java
- at findex --erlang
@findex --gc
@findex --profiling
@findex --memory-profiling
@@ -8257,9 +8217,6 @@ and grade modifier; they are followed by descriptions of those options.
@item @samp{java}
@code{--target java --high-level-code}.
- at item @samp{erlang}
- at code{--target erlang}.
-
@item @samp{.gc}
@code{--gc boehm}.
@@ -8336,11 +8293,9 @@ and grade modifier; they are followed by descriptions of those options.
@item @code{--target c} (grades: none, reg, asm_fast, hlc)
@itemx @code{--csharp}, @code{--target csharp} (grades: csharp)
@itemx @code{--java}, @code{--target java} (grades: java)
- at itemx @code{--erlang}, @code{--target erlang} (grades: erlang)
-Specify the target language used for compilation: C, C#, Java
-or Erlang.
+Specify the target language used for compilation: C, C# or Java.
C means ANSI/ISO C, optionally with GNU C extensions (see below).
-Targets other than C and Erlang imply @samp{--high-level-code}.
+Targets other than C imply @samp{--high-level-code}.
@sp 1
@item @code{--compile-to-c}
@@ -8364,13 +8319,6 @@ An abbreviation for @samp{--target java --target-code-only}.
Generate Java code in @file{@var{module}.java}, but do not invoke
the Java compiler to produce Java bytecode.
- at sp 1
- at item @code{--erlang-only}
- at findex --erlang-only
-An abbreviation for @samp{--target erlang --target-code-only}.
-Generate Erlang code in @file{@var{module}.erl}, but do not invoke
-the Erlang compiler to produce Erlang bytecode.
-
@end table
@node LLDS back-end compilation model options
@@ -8623,7 +8571,7 @@ For now, this option itself is for developers only.
@findex --gc
@findex --garbage-collection
Specify which method of garbage collection to use.
-Grades containing @samp{csharp}, @samp{java}, or @samp{erlang} use
+Grades containing @samp{csharp} or @samp{java} use
@samp{--gc automatic},
grades containing @samp{.gc} use @samp{--gc boehm},
other grades use @samp{--gc none}.
@@ -8632,7 +8580,7 @@ garbage collector.
@c @samp{accurate} is our own type-accurate copying collector.
@c It requires @samp{--high-level-code}.
@samp{automatic} means the target language provides it.
-This is the case for the C#, Java and Erlang back-ends, which always use
+This is the case for the C# and Java back-ends, which always use
the underlying implementation's garbage collector.
@sp 1
@@ -8674,7 +8622,7 @@ accessible via the @samp{thread} module in the standard library.
The runtime uses POSIX threads to achieve this, therefore it may also support
parallel execution of threads.
-The Java, C# and Erlang grades support concurrency without this option.
+The Java and C# grades support concurrency without this option.
Parallel execution may also be available depending on the target's runtime.
@sp 1
@@ -8702,7 +8650,7 @@ attribute. The default is @samp{no}.
Use single precision floats so that, on 32-bit machines
floating point values don't need to be boxed. Double
precision floats are used by default.
-This option is not supported for the C#, Java or Erlang back-ends.
+This option is not supported for the C# or Java back-ends.
@c RBMM is undocumented since it is still experimental.
@c @sp 1
@@ -8912,7 +8860,6 @@ Assume that @var{n} float temporaries will fit into real machine registers.
* Overall optimization options::
* High-level (HLDS -> HLDS) optimization options::
* MLDS back-end (MLDS -> MLDS) optimization options::
-* Erlang (HLDS -> ELDS) optimization options::
* Medium-level (HLDS -> LLDS) optimization options::
* Low-level (LLDS -> LLDS) optimization options::
* Output-level (LLDS -> C) optimization options::
@@ -9434,21 +9381,6 @@ but instead insert calls to the versions of these operations
in the standard library.
@end table
- at node Erlang (HLDS -> ELDS) optimization options
- at subsection Erlang (HLDS -> ELDS) optimization options
- at cindex HLDS
- at cindex ELDS
-
- at table @code
- at item --erlang-switch-on-strings-as-atoms
- at findex --no-erlang-switch-on-strings-as-atoms
- at findex --erlang-switch-on-strings-as-atoms
-Enable a workaround for slow HiPE compilation of large string
-switches by converting the string to an atom at runtime and
-switching on atoms. Do not enable if the string switched on
-could be longer than 255 characters at runtime.
- at end table
-
@node Medium-level (HLDS -> LLDS) optimization options
@subsection Medium-level (HLDS -> LLDS) optimization options
@cindex HLDS
@@ -9848,62 +9780,6 @@ to be quoted when passed to the shell.
Specify the program that implements the Common Language
Infrastructure (CLI) execution environment, e.g. @samp{mono}.
- at sp 1
- at item --erlang-compiler @var{compiler-name}
- at findex --erlang-compiler
- at cindex Erlang compiler
-Specify which Erlang compiler to use. The default is @samp{erlc}.
-
- at sp 1
- at item --erlang-interpreter @var{interpreter-name}
- at findex --erlang-interpreter
- at cindex Erlang interpreter
-Specify which Erlang interpreter to use. The default is @samp{erl}.
-
- at sp 1
- at item --erlang-flags @var{options}
- at itemx --erlang-flag @var{option}
- at findex --erlang-flags
- at findex --erlang-flag
- at cindex Erlang compiler options
-Specify options to be passed to the Erlang compiler.
- at samp{--erlang-flag} should be used for single words which need
-to be quoted when passed to the shell.
-
- at sp 1
- at item --erlang-include-directory @var{dir}
- at itemx --erlang-include-dir @var{dir}
- at findex --erlang-include-directory
- at findex --erlang-include-dir
- at cindex Include directories
- at cindex Directories
-Append @var{dir} to the list of directories to be searched for
-Erlang header files (.hrl).
-
- at sp 1
- at item --erlang-native-code
- at findex --erlang-native-code
- at cindex Erlang compiler options
-Add @samp{+native} to the start of flags passed to the Erlang compiler.
-Cancelled out by @samp{--no-erlang-native-code} so it is useful when you
-wish to enable native code generation for all modules except for
-a select few.
-
- at sp 1
- at item --no-erlang-inhibit-trivial-warnings
- at findex --no-erlang-inhibit-trivial-warnings
- at cindex Erlang compiler options
-Do not add @samp{+nowarn_unused_vars +nowarn_unused_function} to the
-list of flags passed to the Erlang compiler.
-
- at c This option is not fully implemented and not very useful.
- at c @sp 1
- at c @item --erlang-object-file-extension @var{extension}
- at c @findex --erlang-object-file-extension
- at c @cindex File extensions
- at c Specify an extension for Erlang object (bytecode) files. By default this
- at c is @samp{.beam}.
-
@end table
@node Link options
@@ -10002,7 +9878,7 @@ Search @var{directory} for Mercury library files have not yet been
installed. Similar to adding @var{directory} using all of the
@samp{--search-directory}, @samp{--intermod-directory},
@samp{--library-directory}, @samp{--init-file-directory},
- at samp{--c-include-directory} and @samp{--erlang-include-directory}
+and @samp{--c-include-directory}
options, but does the right thing when @samp{--use-subdirs} or
@samp{--use-grade-subdirs} options are used.
@@ -10016,8 +9892,7 @@ options, but does the right thing when @samp{--use-subdirs} or
Append @var{directory} to the list of directories to
be searched for Mercury libraries.
This will add @samp{--search-directory}, @samp{--library-directory},
- at samp{--init-file-directory}, @samp{--c-include-directory}
-and @samp{--erlang-include-directory}
+ at samp{--init-file-directory} and @samp{--c-include-directory}
options as needed. @xref{Using installed libraries with mmc --make}.
@sp 1
@@ -11255,9 +11130,6 @@ Only available on back-ends that compile to C.
@item @samp{C#}
This is the only foreign language for back-ends which compile to C#.
- at item @samp{Erlang}
-This is the only foreign language for back-ends which compile to Erlang.
-
@item @samp{Java}
This is the only foreign language for back-ends which compile to Java.
@@ -11364,9 +11236,6 @@ For those target languages the Mercury runtime will be automatically
initialised when the classes or library assemblies containing code generated
by the Mercury compiler are loaded.
-Stand-alone interfaces are not currently supported when the target language is
-Erlang.
-
For an example of using a stand-alone interface see the
@samp{samples/c_interface/standalone_c} directory in the Mercury distribution.
--
2.28.0
More information about the reviews
mailing list