| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
checked-in lockfiles.
Used a tool to look at lockfiles: when a dependency did not have a corresponding downloaded package, found the latest version that was downloaded and changed the project.json to match. This fixes any packages that don't exist (such as some beta-23302) and floating dependencies (*).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1. Ensures each test has its own unique directory
2. Use Project Reference to refer native CMakeLists.txt
3. Avoids copying the facades to the test build
|
|
|
|
This is a collection of managed runtime tests from an internal legacy test tree.
|
|
The following changes are being submitted in order to prepare for a large collection of tests to be ported from the internal legacy test tree.
- Adds "build kinds" to the test tree.
- Adds some documentation for the test tree
- Adds a Test Priority feature (see documentation Documentation/project-docs/tests.md for more information.
- Dropped the cs_template.csproj types and converted to individual CSProject files.
|
|
Apply [NativeCallable] attribute to a managed method and then it can be
called from native code.Typical use would be passing a managed method as
callback to native, now it can be done by wrapping the method in a
delegate or directly using Marshal.GetFunctionPointerForDelegate.This's
fine as long as we make sure that delegate is not garbage
collected.[NativeCallable] introduce another way, where you can directly
load the function pointer of a native callable method and use it as
callback.This feature cannot be directly used from C#,but can be very
useful in dynamic code generation scenarios where you want a callback to
be passed to native.
Here's an example of how it can be used.
public static class NativeMethods {
[DllImport("user32.dll")]
public static extern int EnumWindows(IntPtr enumProc, IntPtr lParam);
}
//Method attributed with NativeCallable
[NativeCallable]
public static int CallbackMethod(IntPtr hWnd, IntPtr lParam){ return 1; }
Now you can generate the below IL to load native callable function pointer
( LDFTN) and then pass it a native method.
.locals init ([0] native int ptr)
nop
ldftn int32 CallbackMethod(native int,native int)
stloc.0
ldloc.0
ldsfld native int System.IntPtr::Zero
call bool NativeMethods::EnumWindows(native int,native int)
pop
ret
Encoding native callable methods as ENCODE_METHOD_NATIVECALLABLE_HANDLE
so that we don't have to check for the custom attribute at runtime to
decode the method.Also fixing the remaining code review comments.
Adding runtime check to prevent Native Callable methods from being used as
calli target with an ldftn. Also adding some negative test cases , they
are disabled for now since the tests failfast and msbuild report it as
failure.
|
|
1) Float package versions
2) Change readytorun packages to use project.json. The versions that were referenced in the packages.config didn't actually exist anyway, and on machines with cleaner caches, might cause a build breka
3) Lock SIMD packages
|
|
This changes moves coreclr onto DNX (same version as corefx). Theoretically, this should allow these tests to target the desktop CLR. All of the old package.config files are gone and replaced with corresponding project.json files. The up front restore behavior is retained. Tests are now buildable individually, though not runnable in a similar fashion.
|
|
isinst if IsInstanceOfInterface() sets the exception out param.
Correct behavior: If false is returned when IsInstanceOfInterface() called as part of a castclass then the usual InvalidCastException
will be thrown unless an alternate exception is assigned to the castError output parameter.
This parameter is ignored on successful casts or during the evaluation of an isinst (which returns null rather than throwing on error).
|
|
The goal of this change is to facilitate an alternative (MCG based) way of doing COM interop, we're going to use it on Unix platforms.
New ICastable interface allows objects to pretend at runtime that they support an interface and to provide an alternative type that is used to resolve actual calls to interface methods.
BE VERY CAREFUL: This is a very dangerous feature, and at this stage it can easily lead to memory corruption without any native code involved.
Reviewers: Yi Zhang, Noah Falk, Jan Kotas. DDR clean.
[tfs-changeset: 1435198]
|
|
builds the managed components. The managed components can refer to the native projects by the following construct in the .csproj
<ProjectReference Include="CMakeLists.txt">
[tfs-changeset: 1427574]
|
