mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-15 05:44:58 +00:00
57f9013259
Branches: main
Start a C# backend, adapted from mlds_to_java.m.
Some `pragma foreign_*' declarations are commented out in this change because
no bootstrap compiler will yet accept "C#" in the language specification.
The compiler already supported C# foreign_procs for the IL backend, but the IL
backend and this new backend do not agree on naming and calling conventions so
the changes to the existing C# foreign_procs will further break the IL backend.
Nobody cares.
Only tested so far with Mono on Linux.
compiler/mlds_to_cs.m:
New module. In the CVS Attic there exists an obsolete file named
mlds_to_csharp.m (replaced by mlds_to_managed.m) which we don't want to
conflict with.
For C# we need to know if a `pragma foreign_type' is a value or
reference type. Currently this is done by accepting a fake keyword
`valuetype' before the type name, like for IL.
compiler/ml_backend.m:
compiler/mercury_compile.m:
compiler/mercury_compile_mlds_back_end.m:
Hook up the C# backend.
compiler/globals.m:
Add `target_csharp' as a target language.
compiler/options.m:
Add `--csharp' and `--csharp-only' options and their synonyms.
compiler/handle_options.m:
Handle `target_csharp' like `target_java', except for features which
are still to be implemented.
compiler/add_pragma.m:
Allow C# as a `pragma foreign_export' language.
Allow C# for `pragma foreign_export_enum'.
Conform to changes.
compiler/hlds_data.m:
compiler/prog_data.m:
compiler/prog_io_pragma.m:
Accept C# as a language for `pragma foreign_type'.
Accept `csharp' as the name of a grade in trace parameters.
compiler/make_hlds_passes.m:
Reuse most of the code for implementing mutables on Java for C#.
compiler/mlds.m:
Add a new MLDS target language, `ml_target_csharp'.
Conform to changes.
compiler/ml_foreign_proc_gen.m:
Generate foreign_procs for C#.
compiler/foreign.m:
Update predicates to support C# targets.
compiler/c_util.m:
Make `quote_string' use hexadecimal escapes in C# string literals.
compiler/parse_tree.m:
compiler/java_names.m:
Add C# equivalents for predicates in this module. `java_names' is a
misleading module name, but the predicates for C# and Java share some
code and may possibly be combined in the future.
compiler/rtti.m:
Add predicates to return the names of RTTI structures in C#.
compiler/simplify.m:
Handle the trace parameter `grade(csharp)'.
compiler/compile_target_code.m:
compiler/make.dependencies.m:
compiler/make.m:
compiler/make.module_target.m:
compiler/make.program_target.m:
compiler/make.util.m:
Add some support for building of executables and libraries with
`--target csharp'.
compiler/ml_global_data.m:
compiler/ml_optimize.m:
compiler/ml_proc_gen.m:
compiler/ml_switch_gen.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/add_pred.m:
compiler/add_type.m:
compiler/granularity.m:
compiler/inlining.m:
compiler/intermod.m:
compiler/lambda.m:
compiler/mercury_compile_middle_passes.m:
compiler/mercury_to_mercury.m:
compiler/ml_code_util.m:
compiler/ml_disj_gen.m:
compiler/mlds_to_c.m:
compiler/mlds_to_il.m:
compiler/mlds_to_java.m:
compiler/modules.m:
compiler/pragma_c_gen.m:
compiler/prog_foreign.m:
compiler/special_pred.m:
compiler/write_deps_file.m:
Conform to changes.
library/builtin.m:
library/rtti_implementation.m:
library/type_desc.m:
Implement RTTI procedures for the new backend, which uses a high-level
data representation (like the Java backend). The existing C# code was
designed for the IL backend, which used a low-level representation of
the RTTI data structures.
Most (if not all) of the the "new" code is exactly the same as the Java
versions, with only syntactic changes.
Rename the C# class `void_0' to `Void_0' to match the naming convention
used by mlds_to_cs.m.
library/array.m:
Update the existing C# code to work with the new backend.
Use `object[]' as the type of all array of non-primitive types.
The problem is one we encountered on the Java backend: when creating a
new array based on the type of a single element, we don't know whether
the new array should contain elements of the class or superclass.
library/bool.m:
Export `bool' constants to C#.
library/exception.m:
Update the existing C# code to work with the new backend.
Move the `mercury.runtime.Exception' C# class to mercury_dotnet.cs.
library/float.m:
Add C# implementations of `is_nan' and `is_inf'.
library/list.m:
Add methods for manipulating lists from hand-written C# code.
library/string.m:
Add C# implementations of string procedures which were missing.
library/dir.m:
library/io.m:
library/library.m:
Update the existing C# code to work with the new backend.
library/private_builtin.m:
Update the existing C# code to work with the new backend.
Delete the static constants which are duplicated in mercury_dotnet.cs.
The mlds_to_cs.m will emit references to the constants in the latter
only.
library/backjump.m:
library/bitmap.m:
library/mutvar.m:
library/par_builtin.m:
library/region_builtin.m:
library/store.m:
library/thread.m:
library/thread.semaphore.m:
library/time.m:
library/univ.m:
Make these modules compile with the C# backend.
runtime/mercury_dotnet.cs.in:
Add RTTI classes to the `mercury.runtime' namespace, equivalent to
those on the Java backend.
Use enumerations `MR_TYPECTOR_REP_*' and `MR_SECTAG_*' constants so we
can switch on them.
Add the `UnreachableDefault' exception class.
Hide old classes which are unused with the new backend behind
#ifdef !MR_HIGHLEVEL_DATA.
101 lines
3.2 KiB
Mathematica
101 lines
3.2 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 2002-2006, 2009-2010 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU General
|
|
% Public License - see the file COPYING in the Mercury distribution.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% The MLDS back-end.
|
|
%
|
|
% This package includes
|
|
% - the MLDS data structure, which is an abstract
|
|
% representation of a generic imperative language;
|
|
% - the MLDS code generator, which converts HLDS to MLDS;
|
|
% - the high-level C back-end, the Java back-end, the .NET back-end,
|
|
% and a wrapper for the assembler back-end,
|
|
% each of which convert MLDS to their respective target language.
|
|
%
|
|
% The main part of the assembler back-end, which converts MLDS to GCC's
|
|
% internal abstract syntax trees and then invokes the GCC back-end to convert
|
|
% this to assembler, is in a package of its own, so that this package doesn't
|
|
% depend on the GCC back-end.
|
|
%
|
|
:- module ml_backend.
|
|
:- interface.
|
|
|
|
:- import_module hlds.
|
|
:- import_module parse_tree.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- include_module mlds.
|
|
:- include_module ml_util.
|
|
|
|
% Phase 4-ml: MLDS-specific HLDS to HLDS transformations and annotations.
|
|
:- include_module add_heap_ops. % transformation
|
|
:- include_module add_trail_ops. % transformation
|
|
|
|
% Phase 5-ml: compile HLDS to MLDS
|
|
:- include_module ml_proc_gen.
|
|
:- include_module ml_code_gen.
|
|
:- include_module ml_call_gen.
|
|
:- include_module ml_foreign_proc_gen.
|
|
:- include_module ml_closure_gen.
|
|
:- include_module ml_commit_gen.
|
|
:- include_module ml_disj_gen.
|
|
:- include_module ml_switch_gen.
|
|
:- include_module ml_simplify_switch.
|
|
:- include_module ml_string_switch.
|
|
:- include_module ml_tag_switch.
|
|
:- include_module ml_lookup_switch.
|
|
:- include_module ml_type_gen.
|
|
:- include_module ml_unify_gen.
|
|
:- include_module ml_gen_info.
|
|
:- include_module ml_code_util.
|
|
:- include_module ml_accurate_gc.
|
|
:- include_module ml_global_data.
|
|
:- include_module rtti_to_mlds.
|
|
|
|
% Phase 6-ml: MLDS -> MLDS transformations
|
|
:- include_module ml_elim_nested.
|
|
:- include_module ml_optimize.
|
|
:- include_module ml_tailcall.
|
|
|
|
% Phase 7-ml: compile MLDS to target code
|
|
|
|
% MLDS->C back-end
|
|
:- include_module mlds_to_c.
|
|
|
|
% MLDS->Assembler back-end
|
|
:- include_module maybe_mlds_to_gcc.
|
|
% :- include_module mlds_to_gcc
|
|
% :- include_module gcc.
|
|
|
|
% MLDS->Java back-end
|
|
:- include_module mlds_to_java.
|
|
:- include_module java_util.
|
|
|
|
% MLDS->C# back-end.
|
|
:- include_module mlds_to_cs.
|
|
|
|
% MLDS->.NET CLR back-end
|
|
:- include_module il_peephole.
|
|
:- include_module ilasm.
|
|
:- include_module ilds.
|
|
:- include_module mlds_to_il.
|
|
:- include_module mlds_to_ilasm.
|
|
:- include_module mlds_to_managed.
|
|
|
|
:- implementation.
|
|
|
|
:- import_module backend_libs.
|
|
:- import_module libs.
|
|
:- import_module check_hlds. % needed for type_util, mode_util,
|
|
% and polymorphism.
|
|
:- import_module mdbcomp.
|
|
|
|
:- end_module ml_backend.
|
|
|
|
%-----------------------------------------------------------------------------%
|