Compare commits

...
735 Commits
Author SHA1 Message Date
Neale Ferguson 89bf42b05f Use thread priority at thread start time (#3123)
* An enhancement to the thread priority work added earlier. This will support starting a thread with a specified priority. Currently, the thread will start with the priority of the creator. The semantics of threads allow you to specify the priority of a thread before it has started. Therefore, we take note of this value at thread creation time.

* Missed committing this file the first time

* Correct typo

* Fix creation_flags reference

* MonoThreadParm really should not be in objects-internal

* Place priority in MonoInternalThread where it can be accessed by GetThreadPriority(). This enablses the priority to be set/retrieved before the thread is started. It also ensures that new threads default to a priority of THREAD_PRIORITY_NORMAL rather than inheriting the parent thread's priority.

* Revert changes to MonoInternalThread/Thread.cs. Properly use the handle for thread lookup. Initialize priority at thread creation time. Use stored value of priority if thread has not been started.

* Add code to handle retrieving the thread priority from a started thread that had been set before thread had started. This is necessary as before the thread is started the priority value can be manipulated. This value is stored in the MonoThread structure. Before the thread is started the value can be interrogated so we return this value rather than invoking the GetThreadPriority() API. When a thread is started this value is used to set the threads priority (if scheduling policy is SCHED_FIFO or SCHED_RR). For POSIX threads, after the thread is started we now keep the priority in the _Wapi_thread structure which is located via the thread handle. This structure doesn't exist until after the thread is started so we can't store the value there but after we can cache the priority value there and return it for non-SCHED_[RR|FIFO] threads. This way the expected value will always be set and returned by ThreadPriority property (currently for these threads it will simply return Normal). A test case has been added to the mono/tests directory.

* Use a copy of creation_flags so local modifications aren't propagated

* Use pthread_setschedparam as OSX doesn't support pthread_setschedprio
2016-06-20 10:26:51 -04:00
Marek Safar 081781dd93 [reflection] Improves 1a820fcdc0 to do vslot match as optimization only 2016-06-20 13:43:15 +02:00
Alexander Köplinger 88bf878a7f Merge pull request #3179 from gttds/patch-2
[System.Web] Fixes 50 year form authentication
2016-06-20 13:33:59 +02:00
João Matos d1d72cdfa9 Merge pull request #3184 from tritao/zip_datetime
[System.IO.Compression] Fixed Zip entries with unset last write time to return the same as .NET.
2016-06-20 12:18:12 +01:00
Marek Safar 1d73474cbc Merge pull request #3183 from marek-safar/bug41874
[reflection] Properties always use name and signature hidding rules. …
2016-06-20 11:44:42 +02:00
Marek Safar b7734fb631 [System.Web] Fixes SkinID property declaration 2016-06-20 11:33:07 +02:00
Zoltan Varga 1190e15f01 [llvm] Fix the allocation of vregs for the OP_MIN/MAX opcodes. Fixes #41947. 2016-06-18 20:01:42 -04:00
Zoltan Varga 72998aa615 Revert "[llvm] Fix the allocation of vregs for the OP_MIN/MAX opcodes. Fixes #41947."
This reverts commit 4cbef26bb7.

Revert this to see if it fixes the windows build.
2016-06-18 16:16:43 -04:00
Alexander Kyte d7eaad3f48 [runtime] Don't call ExecutionEngine constructor in aot mode (#3185) 2016-06-18 13:12:15 -04:00
Zoltan Varga 1d69617204 [aot] Add support for array accessor methods for multi-dimensional arrays. Fixes #41937. 2016-06-17 20:46:26 -04:00
Zoltan Varga 4cbef26bb7 [llvm] Fix the allocation of vregs for the OP_MIN/MAX opcodes. Fixes #41947. 2016-06-17 17:26:47 -04:00
João Matos bd938a4818 [System.IO.Compression] Fixed Zip entries with unset last write time to return the same as .NET.
.NET on Windows returns a fixed date for this, replicate the same behaviour in Mono.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=40916.

See also: https://github.com/NuGet/Home/issues/2518
2016-06-17 18:23:05 +01:00
Marek Safar 1a820fcdc0 [reflection] Properties always use name and signature hidding rules. Fixes #41874 2016-06-17 18:44:45 +02:00
Dunati 15fedcada9 Fix for x86 and amd64 continuations (#3182) 2016-06-16 19:15:14 -07:00
Zoltan Varga 3c9f7f0967 [aot] Fix leaking a MonoError. 2016-06-16 19:07:22 -04:00
Zoltan Varga caf57b42be [aot] Avoid asserting if loading a type fails. 2016-06-16 19:04:33 -04:00
Bernhard Urban 2243eec53b Merge pull request #3163 from alexanderkyte/fast_context_clean
[runtime] Store abremoval context statuses seperately to use memset for cleanup
2016-06-16 11:51:59 -07:00
Alexander Kyte 123aa41caf [bcl] Remove cosmetic target that always triggers a rebuild (#3180) 2016-06-16 11:51:31 -07:00
Marek Safar 4ef940ca14 Merge pull request #3175 from marek-safar/cas-cleanup
[bcl] Make mono cas opt-in features instead of opt-out for mobile pro…
2016-06-16 20:35:13 +02:00
gttds b499a3e00b [System.Web] Fixes 50 year form authentication
This fixes the bug where form authentication tickets do not expire until 50 years later.
I bumped into this bug after upgrading mono from 4.2.2 to 4.4.0

Firstly, the authentication ticket's expiry must always equal to the timeout attribute on the <forms/> element. It doesn't matter whether persistent or session cookies are used. 

Secondly, if the cookie is persistent, then it's expiry should be set to the same as that of the authentication ticket.

Reference: https://blogs.msdn.microsoft.com/dansellers/2006/02/15/change-to-asp-net-2-0-forms-authentication-persistent-cookies/
2016-06-16 23:46:21 +08:00
Marek Safar d35b5d2188 [System] Put back handling of direct ip addresses to ServicePoint::HostEntry (removed in 932359f3d6). Fixes #41782 2016-06-16 17:46:18 +02:00
Alexander Kyte f8977a0f6c [runtime] Return early so mono_value_box_checked doesn't clobber error (#3172) 2016-06-16 11:18:19 -04:00
Alexander Kyte 1796ad4200 [runtime] Store abremoval context statuses seperately to use memset for cleanup 2016-06-16 11:06:23 -04:00
Marek Safar ed989a8e9e [bcl] Make mono cas opt-in features instead of opt-out for mobile profiles 2016-06-16 14:37:55 +02:00
João Matos 934fe68aea Merge pull request #3176 from lateralusX/jlorenss/win-fix-test-dllimport-path
Update to tests config file reflecting changed libtest module location on Windows.
2016-06-16 12:14:41 +01:00
João Matos dfb71501df [System.IO.Compression] Fixed version needed to extract value in Zip central directory record entry.
This should fix some problem with Nuget archives created by Mono.

No test case for this one because it would involve writing a mini-ZIP file parser to make sure the value is written correctly (or hardcore the value offset in the generated file, which could lead to a very flakey test).

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=41775.
2016-06-16 12:12:32 +01:00
lateralusX 04b168129d Update to tests config file reflecting changed libtest module location.
Updated Visual Studio build uses a different default build location of modules
compared to previous version. The tests config file includes a relative
path to libtest used for by all pinvoke tests. Since the module is now
placed at a different location the load failed during the test.
2016-06-16 13:10:04 +02:00
Alexander Kyte b10c89c904 Merge pull request #3174 from alexanderkyte/revert_jay_relative
Revert "[runtime] Fix jay path in Microsoft.Build"
2016-06-15 18:30:52 -04:00
Alexander Kyte 2fb5ec70eb Revert "[runtime] Fix jay path in Microsoft.Build"
This reverts commit 6780bb169c.
2016-06-15 18:29:21 -04:00
Zoltan Varga fd2a124926 [llvm] Enable support for Selector.GetHandle (). Enable it for Xamarin.Mac as well. 2016-06-15 17:54:36 -04:00
Alexander Kyte c486ddc4fc Merge pull request #3173 from alexanderkyte/jay_build_path_fix
[runtime] Fix jay path in Microsoft.Build
2016-06-15 17:47:02 -04:00
Alexander Kyte 6780bb169c [runtime] Fix jay path in Microsoft.Build 2016-06-15 17:37:11 -04:00
Zoltan Varga eb34dbd0fc [llvm] Add suport for OP_OBJC_GET_SELECTOR, not enabled yet. 2016-06-15 16:05:24 -04:00
monojenkins bc6f673c13 Merge pull request #3169 from lambdageek/fix-regression-70561
[coop] Fix regression in bug-70561.cs

Match behavior of non-coop and don't set an exit code if the main method
throws an unhandled exception.
2016-06-15 16:18:42 +01:00
Alexander Kyte d2cc9be75b Merge pull request #3171 from alexanderkyte/net_4x_mdoc_fixup
[runtime] Fix inverted build check related to mcs docs
2016-06-15 10:25:28 -04:00
Alexander Kyte f17ae9e2cd [runtime] Fix inverted build check related to mcs docs 2016-06-15 10:22:50 -04:00
João Matos 611325c072 Merge pull request #2972 from lateralusX/jlorenss/vs2015-upgrade
Visual Studio project/solution upgrade and enhancement.
2016-06-15 10:56:04 +01:00
lateralusX 5adfe65a07 Fix pedump build errors due to moved source file.
Changes done in commit 2f6e404ed1 moving
pedump.c to different location cause build errors of pedump on Windows.
2016-06-15 11:08:16 +02:00
lateralusX fc9396edf2 Reverted back to use target name for library pdb files and default
naming for intermediate pdb files for exe/dll's.

All artifacts will now have the same name of their final pdb file as
the library/dll/exe target file name.

The problem with the naming turns out to be a problem in Visual Studio
when a exe/dll use the same name of its intermediate pdb files and final
pdb file. In that case the final pdb file produced by the linker will be
incorrect and not usable by the debugger. This was the reason for the initial
change, giving intermediate pdb files a different name. Moving back to the
default naming for intermediate pdb files for exe/dll's will give the same
effect (a different name) and since libraries are not affected by this
problem, libraries can use the target name for their pdb files as well.
2016-06-15 09:44:24 +02:00
lateralusX 91e96b3d7f Added new sources to Source Folder filter in libmonoutils. 2016-06-15 09:44:24 +02:00
lateralusX 69e25e0087 Disable build of boehm GC on Windows x64. 2016-06-15 09:44:24 +02:00
lateralusX 2cad193fc5 Added support to select static or dynamic c-runtime based on user property.
All projects will inherit the RuntimeLibrary from mono.props where it now
can be controlled using a user property, MONO_USE_STATIC_C_RUNTIME.
2016-06-15 09:44:24 +02:00
lateralusX 0e0002e255 Fixed .bat file to handle xcopy command not in path.
Also added support to not always replace config.h/version.h since that triggers
unnecessary rebuilds during development. New script will check if there is
an actual difference in the config.h/version.h file before doing the copy.
2016-06-15 09:44:24 +02:00
lateralusX c60a49439a Added support to split GC builds into different build folders. 2016-06-15 09:44:24 +02:00
lateralusX 106908689a Added files to corresponding filter folders (header files/source files). 2016-06-15 09:40:06 +02:00
lateralusX 6052043fd9 Fixes to default build/distribution location. 2016-06-15 09:40:06 +02:00
lateralusX 35f830a6f2 Added additional build dependecies + setting up source availabilty depending on platform. 2016-06-15 09:40:06 +02:00
lateralusX aa4f4e6962 Added support for 64 toolchain + default log level masks. 2016-06-15 09:40:06 +02:00
lateralusX d966314db5 Added regression tests as visual studio projects.
* Added regression test running mono/mini --regression [regression_tests]
* Added regression test running mono/mini --aot [regression_tests]
* Added default debugging options to run regression tests from within visual studio debugger.
* On new build system, setting up include folder if not availalble.

All changes applies to debug/release 32/64 bit.
2016-06-15 09:40:06 +02:00
lateralusX e13440bf6a Added missing include path for test projects.
On a clean system there was a missing include path for some of the embedded samples.
2016-06-15 09:40:06 +02:00
lateralusX 2ed1acdf7b Added regression test project.
* Updated vs project files to resolve winsock, winsock2 build dependecies.
* Added vs project running basic mono-mini regression tests.
2016-06-15 09:40:06 +02:00
lateralusX 3360c14f65 Added suffix to intermediate build .pdb files in order to avoid potential naming conflicts when linking. 2016-06-15 09:40:06 +02:00
lateralusX 5ffb067e88 Added support for optional target build suffix. 2016-06-15 09:40:06 +02:00
lateralusX 51870b34bd Better property manager and user macros support.
* Added support for user macros in order to set build/install/sgen.
* Added support for more arguments to bat files + support for quoted paths.
* Added support for verbose/quite output in bat files.
* Moved libmono xcopy post build step into separate bat file.
* Cleaned some sgen configs still left in vcxprojs.
2016-06-15 09:40:06 +02:00
lateralusX b1c604eee2 Separate build tree and target suffix support.
* Enabled build target suffix in order to lable a build (primarly for sgen).
* Enabled separate build tree.
* Dropped all sgen configurations, replaced by properties and target suffix.
* Fixed pdb naming of intermediate pdb files.
2016-06-15 09:40:06 +02:00
lateralusX c371f4f33c Restructured build/package/install targets and split GC libraries.
* Added package/install targets.
* Moved sgen into separate library.
* SGEN set as default GC for build (used GC controlled through mono.props).
2016-06-15 09:40:06 +02:00
lateralusX 01551beda6 Refactored VS depdencies + restructring VS solution and projects. 2016-06-15 09:40:06 +02:00
lateralusX 8938bfd232 Upgrade to vs2015 for native projects.
* Upgraded all projects to new vs2015 tool chain.
* Used mono.props through property manager instead of import.
* Fixed dependencies to be more explicitly in additional dependecies.
* Fixed error in mono.props, switched $ to % when referencing internal variables.
* Added property variables for includes and libraries, defined in mono.props.
2016-06-15 09:40:06 +02:00
Miguel de Icaza 0aa112f9dd [mkbundle] Improve error checking 2016-06-14 23:25:30 -07:00
Miguel de Icaza ab73f54d42 [main] replace computed value by a constant
The reason why mkbundle is not working is that for some reason
this constant expression is producing different code than the
-24 that it is supposed to.

What is odd is that the return value from the lseek system
call is the same, but yet, read fails with an end-of-file with
this value, and otherwise it passes.

With this call:

     lseek (fd, -(16+sizeof(uint64_t)), SEEK_END)

strace displays:

lseek(0x3, 0xFFFFFFE8, 0x2)		 = 19375512 0

With this call:

     lseek (fd, -24, SEEK_END)

strace displays:

lseek(0x3, 0xFFFFFFFFFFFFFFE8, 0x2)	 = 19375512 0

Now, while both results from lseek are the same, a subsequent read
with 24 bytes to read returns zero on the former case, and 24 on
the latter case.
2016-06-14 23:25:30 -07:00
Alexander Köplinger 3e22f8a53f [mcs] Use $(RESGEN) instead of resgen
It broke the .deb package build
2016-06-15 03:12:02 +02:00
Alexander Köplinger 5479142e8b Merge pull request #3168 from alexanderkyte/default_4_x_preset
[runtime] Make the default preset only build net_4_x
2016-06-15 01:16:49 +02:00
Aleksey Kliger 43d8951c78 [coop] Fix regression in bug-70561.cs
Match behavior of non-coop and don't set an exit code if the main method
throws an unhandled exception.
2016-06-14 19:11:19 -04:00
Alexander Kyte 1586896f99 [runtime] Make the default preset only build net_4_x 2016-06-14 19:08:31 -04:00
Alexander Kyte 65efedb894 Merge pull request #3089 from alexanderkyte/mobile_static_jenkins_script
[mobile_static] Update jenkins build script for mobile_static profile
2016-06-14 18:24:26 -04:00
Zoltan Varga 0f996d6020 [runtime] [runtime] Fix the printing of unhandled exceptions in coop. 2016-06-14 18:06:58 -04:00
Zoltan Varga d71f485af7 [runtime] Return after setting the error in mono_jit_runtime_invoke (), otherwise mono_value_box_checked () initializes it again. 2016-06-14 18:06:58 -04:00
Miguel de Icaza aff1a51a38 WIP [library.make] Make resource usage declarative in the class libraries (#3159)
[library.make] Make resource usage declarative in the class libraries
2016-06-14 13:57:09 -07:00
Zoltan Varga 6b3a592de0 [jit] Set the 'real_offset' field of bblocks in mono_replace_ins (), the EH code generator in llvm depends on it being set. 2016-06-14 15:36:44 -04:00
Alexander Köplinger ca606bbefa Merge pull request #3165 from akoeplinger/fix-clock-monotonic-macos1012
[utils] Work around CLOCK_MONOTONIC being defined on macOS 10.12 SDK despite targeting earlier releases
2016-06-14 19:08:11 +02:00
Marek Safar bc5e8fbf5c [mcs] Support System.Object forwarded to any assembly in any references order 2016-06-14 19:03:59 +02:00
Alexander Köplinger b821c8e33c [utils] Work around CLOCK_MONOTONIC being defined on macOS 10.12 SDK despite targeting earlier releases
Should fix https://bugzilla.xamarin.com/show_bug.cgi?id=41786
2016-06-14 16:39:41 +02:00
Alexander Kyte d6025dec80 Merge pull request #3162 from alexanderkyte/ignore_pkits
[mobile_static] Skip PKITS tests on mobile_static due to missing
2016-06-13 16:06:28 -04:00
Aleksey Kliger (λgeek) fdfa5d8461 [coop] Protect copy_stack_data from GCC optimizations. (#3157)
[coop] Protect copy_stack_data from GCC optimizations.

GCC 5.3.1 (Debian sid/amd64) "optimizied" the previous incarnation of
`void *stackdata_end = return_stack_ptr ()` to
`void *stackdata_end = 0`.
2016-06-13 15:58:44 -04:00
Alexander Kyte 0b3e113656 [mobile_static] Make bitcode preset enable llvm 2016-06-13 14:53:51 -04:00
Alexander Kyte 53b79e4a91 [mobile_static] Skip PKITS tests on mobile_static due to missing
fixtures
2016-06-13 14:31:40 -04:00
Bernhard Urban 06c67d8075 Merge pull request #3160 from JustArchi/patch-1
SGen: Fix parsing of default-allowance-ratio
2016-06-13 09:56:27 -07:00
Alexander Kyte 6f876c4bbc [runtime] Rename the net_4_x runtime preset to all 2016-06-13 12:16:24 -04:00
Alexander Kyte 280906915b [runtime] Keep one-off jenkins disabling in script 2016-06-13 12:16:24 -04:00
Alexander Kyte cc9a2a0379 [runtime] Allow presets to disable runtime features 2016-06-13 12:16:24 -04:00
Alexander Kyte 62898add79 [mobile_static] Update reported FX version to 4.x 2016-06-13 12:16:23 -04:00
Alexander Kyte cd81b965b8 [mobile_static] Set default value for disabling MCS docs 2016-06-13 12:16:23 -04:00
Alexander Kyte b6af11c6a9 [mobile_static] Split jenkins tests out, enable running from top level 2016-06-13 12:16:23 -04:00
Alexander Kyte 6e5479c540 [runtime] Make cooperative gc default on our bitcode profile 2016-06-13 12:16:22 -04:00
Alexander Kyte a1800e89ce [mobile_static] Use runtime_preset configuration option 2016-06-13 12:16:22 -04:00
Alexander Kyte 67ccd74036 [mobile_static] Disable NLS by default on OSX 2016-06-13 12:16:22 -04:00
Alexander Kyte 87d30ece8b [mobile_static] Added in runtime_profile autoconf flag, make set
defaults
2016-06-13 12:16:21 -04:00
Alexander Kyte b5a550bb97 [mobile_static] Make mobile_static default profile when building with it
When building a mobile_static build, we need to pass a lot of flags
which disable features. These make the net_4_x profile not build
correctly when using the official jenkins script. This helps.
2016-06-13 12:16:21 -04:00
Alexander Kyte 630bea6983 [mobile_static] Fix configure.ac handling of with_profile4_x option 2016-06-13 12:16:21 -04:00
Alexander Kyte 12b32e2334 [runtime] Specialize run-jenkins script for mobile_static when it runs 2016-06-13 12:16:20 -04:00
Aleksey Kliger (λgeek) c6f75c367a Merge pull request #3106 from lambdageek/dev/monoerror-unhandled
[runtime] Okay to raise MonoError in thread start functions.
2016-06-13 11:52:35 -04:00
Marek Safar b5dc9a4951 [System] Fixes crash during implicit file uri parsing with unicode characters 2016-06-13 17:21:51 +02:00
Alexander Köplinger 288535ce9d Merge pull request #3161 from ntherning/use_msvc_built_libtest_dll_for_runtime_tests_on_windows
Use the MSVC built libtest.dll when running the P/Invoke tests in mono/tests/ on Windows
2016-06-13 16:42:20 +02:00
Niklas Therning 0bbf9c3a73 Use the MSVC built libtest.dll when running the P/Invoke tests in mono/tests/
on Windows. Updates the tests-config.in file with Windows specific <dllmap>
elements that map 'libtest' to the MSVC built libtest.dll for the current
architecture. test-runner.cs has been modified to accept a --config option to
be able to use a specific config file. Makefile.am now configures test-
runner.exe to use the tests-config config when running the tests.
2016-06-13 10:50:19 +02:00
Łukasz Domeradzki 6ceccb40de SGen: Fix parsing of default-allowance-ratio
Parsing ```default-allowance-ratio``` in ```MONO_GC_PARAMS``` is completely broken and accepts only one value - 1.0, while it should accept range of 1.0-10.0. We can clearly notice that when setting ```default-allowance-ratio``` to e.g. ```2.0``` and trying to run any program through Mono runtime:

```
Warning: In environment variable `MONO_GC_PARAMS': `default-allowance-ratio` must be between 1.00 - 1.00. - Using default value.
```

Therefore, correct this for using proper 1.0-10.0 range.
2016-06-13 05:28:22 +02:00
Aleksey Kliger (λgeek) 81a6cf5ece [runtime] Don't raise ArgumentNullException in mono_monitor_enter_fast (#3158)
Just return that you couldn't enter the monitor and let the slow path handle it.

Fixes [#41705](https://bugzilla.xamarin.com/show_bug.cgi?id=41705)
2016-06-12 17:32:07 -04:00
Sebastien Pouliot 999ed78aa7 [System.Net.Http] Fix CFNetworkHandler.CookieContainer not to return null (#3141)
* [System.Net.Http] Fix CFNetworkHandler.CookieContainer not to return null

This aligns the handler with the managed HttpClientHandler [1] and make
it easier to switch between them without additional or conditional code.

[1] https://github.com/mono/mono/blob/14f8acced5bbb2f6d55fb3e7800382700bcc65eb/mcs/class/System.Net.Http/System.Net.Http/HttpClientHandler.cs#L97
2016-06-11 14:21:21 -04:00
Zoltan Varga fe50acb6ff [runtime] Avoid building the tools dir when cross-compiling, some tools don't seem to compile. 2016-06-10 22:48:27 -04:00
Zoltan Varga d21e1be2b1 [amd64] Handle native types correctly in mono_arch_get_llvm_call_info (). 2016-06-10 22:48:27 -04:00
Zoltan Varga f098db9484 [jit] Add some missing opcodes to MONO_IS_SETCC. 2016-06-10 22:48:27 -04:00
Alexander Köplinger 171a69b668 Merge pull request #3152 from ntherning/use_env_configured_mono_exe_in_runtime_tests
Make mono/tests/Makefile.am use MONO_EXECUTABLE if set
2016-06-10 23:39:25 +02:00
Marek Safar 129e6c3220 [mscorlib] Better handling of unix timezones which have offset not specified in whole minutes. Fixes #41492 2016-06-10 21:53:29 +02:00
Alexander Köplinger b6b1525709 [tools] Add a few missing files to the tarball
Those turned out to be missing when building tools/ was enabled by default.
Also ignore some stuff in .gitignore
2016-06-10 21:11:03 +02:00
Aleksey Kliger (λgeek) 78e5ac0f8f [runtime] Fix MonoError lifecycle in do_try_exec_main (#3145)
The do_try_exec_main function is always called in contexts where any
exception from doing the invoke is going to be stored in the exc outarg.
That means any MonoError will be handled locally by do_try_exec_main.
So we don't need a MonoError argument, we just need an inner_error.
2016-06-10 14:59:53 -04:00
Martin Baulig aef549e364 Merge pull request #3144 from Unity-Technologies/fix-recursive-property-call
Fix recursive property call in MonoSslStreamImpl
2016-06-10 20:23:35 +02:00
Aleksey Kliger (λgeek) 8b57a81993 Merge pull request #3154 from lambdageek/fix-initmessage-linker
[linker] Add MonoMethodMessage::InitMessage to mscorlib descriptor
2016-06-10 11:54:29 -04:00
Aleksey Kliger 8799f317dd [linker] Add MonoMethodMessage::InitMessage to mscorlib descriptor
That method gets called from the runtime, it shouldn't be linked out.
2016-06-10 11:23:12 -04:00
Alexander Köplinger 0fa5f5fb4f [tests] Bump timeout in sleep.exe
We're seeing it randomly fail on Wrench with durations of 1550 - 1800ms.
Talked to Zoltan, this might be normal so bumping the timeout to reduce the failure rate.
2016-06-10 16:32:21 +02:00
Marek Safar 78bf2b6cc2 [System] Read all values of unknown/uncommon headers with multiple entries. Fixes #41552 2016-06-10 13:00:06 +02:00
Alexander Kyte b1dccbc236 [runtime] Ensure uniqueness of icall wrappers (#3143)
The llvmonly backend will use `mono_aot_init_gshared_method_this`
and other initializers to initialize methods. These will transitively call
`mono_icall_get_wrapper_full` when icall wrappers are needed.

The init functions will set the
initialized flag after initialization. They set it in a non-atomic manner. This means that
in a multithreaded environment, it's possible to call the functions
twice.

When `mono_icall_get_wrapper_full` is called without this patch, the
pointers to wrappers it gets from `mono_marshal_get_icall_wrapper`
will not have the same addresses. They will hash to the same value
though.

This will lead to them not being found or inserted by
`find_aot_method_in_amodule`.
The fact that we already have a value with this hash means that
the new wrapper doesn't get inserted. The fact that the pointers differ
mean that we don't say that we've found our desired wrapper.

This leads to an assertion in `mono_icall_get_wrapper_full`
crashing the runtime.

Since we intend to have the semantics of a wrapper for each icall,
this change uses a cache to ensure uniqueness. The observed crashes
do not happen when this change is applied.
2016-06-10 05:05:51 -04:00
Marek Safar b0fd769485 Merge pull request #3151 from akoeplinger/fix-islocal
[System] Fix HttpListenerRequestTest.HttpRequestIsLocal intermittently failing
2016-06-10 10:13:59 +02:00
Niklas Therning 68af1e0192 Modifies mono/tests/Makefile.am to pass along the value set in the
MONO_EXECUTABLE env variable to test-runner.exe using the --runtime command
line parameter. Defaults to 'mono' which is also the defult in test- runner.cs
if no --runtime argument is given.
2016-06-10 09:46:04 +02:00
Zoltan Varga 2f6e404ed1 [runtime] Move 'pedump' to tools/pedump, build tools by default. (#3133)
* [runtime] Move 'pedump' to tools/pedump, build tools by default.

* Add missing file.

* [runtime] Mark mono_opcodes[] with MONO_API.

* [runtime] Build monograph when sgen is supported instead of boehm.

* [runtime] Link monograph against the static runtime libraries.

* [runtime] Use the same SUBDIRS/DIST_SUBDIRS for the CROSS_COMPILING case.
2016-06-10 02:52:03 -04:00
Alexander Köplinger ff55074476 Merge pull request #3140 from esdrubal/syscall_details
[runtime] Fixed interruptible wapi_sendfile part2.
2016-06-10 01:48:19 +02:00
Alexander Köplinger 0178821e50 [System] Fix HttpListenerRequestTest.HttpRequestIsLocal intermittently failing
We're seeing the following exception on devices in CI:

```
[FAIL] HttpListenerRequestTest.HttpRequestIsLocal : System.Net.Sockets.SocketException : Could not resolve host 'XQA-AppleTV-1'
	  at System.Net.Dns.Error_11001 (System.String hostName) [0x00000] in /Users/builder/data/lanes/1381/d8287824/source/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/src/mono/mcs/class/System/System.Net/Dns.cs:292
	  at System.Net.Dns.GetHostByName (System.String hostName) [0x00024] in /Users/builder/data/lanes/1381/d8287824/source/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/src/mono/mcs/class/System/System.Net/Dns.cs:419
	  at System.Net.Dns.GetHostEntry (System.String hostNameOrAddress) [0x00061] in /Users/builder/data/lanes/1381/d8287824/source/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/src/mono/mcs/class/System/System.Net/Dns.cs:380
	  at System.Net.Dns.GetHostAddresses (System.String hostNameOrAddress) [0x00065] in /Users/builder/data/lanes/1381/d8287824/source/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/src/mono/mcs/class/System/System.Net/Dns.cs:406
	  at MonoTests.System.Net.HttpListenerRequestTest.HttpRequestIsLocal () [0x00006] in /Users/xamarinqa/QABot/data/lanes/2441/d8287824/source/xamarin-macios/external/mono/mcs/class/System/Test/System.Net/HttpListenerRequestTest.cs:197
	  at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
	  at System.Reflection.MonoMethod.Invoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00038] in /Users/builder/data/lanes/1381/d8287824/source/xamarin-macios/_ios-build/Library/Frameworks/Xamarin.iOS.framework/Versions/git/src/mono/mcs/class/corlib/System.Reflection/MonoMethod.cs:309
```

From looking at the code, resolving the hostname to IP addresses via DNS fails so the test doesn't even run.
We don't care where the local IPs come from so we can use an alternative way of getting them - via querying the network interfaces.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=41671

PS: fixed a hardcoded port while I was touching the code
2016-06-10 01:39:14 +02:00
monojenkins cadf391bea Merge pull request #2921 from lewurm/lower-typechecks-later
[mini] lower typechecks later

lower typecheck instructions later in the compilation, so we've a chance to do high-level optimization after `method-to-ir`
2016-06-10 00:05:15 +01:00
monojenkins 59ec6fd3d6 Merge pull request #3121 from lambdageek/dev/managed-init_message
Rewriite `MonoMethodMessage::InitMessage` in managed code

Change icall
`System.Runtime.Remoting.Messaging/MonoMethodMessage::InitMessage` to
managed code.

Also update `mono_message_init()` to invoke `InitMessage`.
2016-06-09 23:15:10 +01:00
Rodrigo Kumpera 10fb3e1955 [sgen] Inform on configure and --version when the concurrent GC is the default. 2016-06-09 13:39:53 -07:00
Bernhard Urban 4b094daa6a [mini] execute decompose_typechecks only if there's a typecheck operation 2016-06-09 13:32:36 -07:00
Bernhard Urban a13370db72 [mini] comment about empty BBs for graph visualization 2016-06-09 13:32:36 -07:00
Bernhard Urban 0340dfb1ec [mini] do decomposition of typechecks later in the compilation pipeline 2016-06-09 13:32:36 -07:00
Bernhard Urban 9cd83a3c06 [method-to-ir] get rid of additional reg introduced for isinst and castclass 2016-06-09 13:32:36 -07:00
Bernhard Urban 82b0502f7c [mini] add time tracking for decompose_typechecks pass 2016-06-09 13:32:36 -07:00
Bernhard Urban 31db83596d [mini] decompose isinst and castclass in a later pass 2016-06-09 13:32:36 -07:00
Bernhard Urban 0975b0d13b [cfgdump] insert NOP in empty basic blocks in order to not confuse graph dumper 2016-06-09 13:32:36 -07:00
Bernhard Urban 70b42fc580 [debug] print class name for OP_{isinst,castclass} 2016-06-09 13:32:36 -07:00
Bernhard Urban 7ab1f37abb [mini] introduce OP_{isinst,castclass} 2016-06-09 13:32:36 -07:00
Vlad Brezae b2cf7bbf84 Merge pull request #3136 from BrzVlad/fix-stw-stopped
[sgen] Don't try to stop a stopped world
2016-06-09 23:13:56 +03:00
Aleksey Kliger 5a7f490680 [runtime] Switch mono_message_init to invoke managed
Invoke the managed
System.Runtime.Remoting.Messaging.MonoMethodMessage::InitMessage method.
2016-06-09 14:52:52 -04:00
Aleksey Kliger 83f3716119 [corlib] Implement MonoMethodMessage::InitMessage in managed
Change icall
System.Runtime.Remoting.Messaging/MonoMethodMessage::InitMessage to
managed code.
2016-06-09 14:52:52 -04:00
Alex Rønne Petersen d43ea3ac56 Merge pull request #3127 from alexrp/arm32-on-arm64
[arm] Correctly detect hardware features when running as arm32 on arm64 hardware.
2016-06-09 20:29:31 +02:00
Bernhard Urban 95e805c52a Merge pull request #3137 from BrzVlad/fix-sgen-critical-region
[sgen] Exit the critical section also on the slowpath of managed allocators
2016-06-09 10:31:49 -07:00
monojenkins 68be3904cf Merge pull request #3142 from henricm/fix-for-win-mono_string_to_utf8
Using mono_marshal_free n mono_string_builder_to_utf8

`mono_string_builder_to_utf16` is allocating using `mono_marshal_alloc` which, on windows, allocates memory using `CoTaskMemAlloc`. This buffer was then released in `mono_string_builder_to_utf8` using `g_free` which resulted in a crash since that's a different memory on windows. The fix in this PR makes sure `mono_marshal_free` is called instead which has the correct behaviour and results in a `CoTaskMemFree` on windows.
2016-06-09 17:55:12 +01:00
Marek Safar 0f93f3f98d [mcs] Add probing conversion for FormattableString. Fixes #41575 2016-06-09 17:55:19 +02:00
Mike Voorhees ef0c4d2c1b Fix recursive property call in MonoSslStreamImpl 2016-06-09 10:50:37 -04:00
Johan Lorensson 14f8acced5 Merge pull request #3085 from lateralusX/jlorenss/win-x64-pinvoke-empty-struct
Fix for non GCC win x64 calling convention when passing empty structs over pinvoke.
2016-06-09 15:49:33 +02:00
Henric Müller 18c8694c0d Making sure mono_marshal_free is used instead of g_free in mono_string_builder_to_utf8 2016-06-09 15:40:30 +02:00
monojenkins 975fc21341 Merge pull request #3139 from akoeplinger/dns-test
[System] Make ServicePointTest.DnsRefreshTimeout test more reliable

We are still seeing quite rare failures of this test:

```
HostEntry should result in the same IPHostEntry object.
  Expected: same as <System.Net.IPHostEntry>
  But was:  <System.Net.IPHostEntry>

+++++++++++++++++++
STACK TRACE:
at MonoTests.System.Net.ServicePointTest.DnsRefreshTimeout () [0x00045] in /Users/builder/jenkins/workspace/test-mono-mainline/label/osx-i386/mcs/class/System/Test/System.Net/ServicePointTest.cs:228
at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
at System.Reflection.MonoMethod.Invoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00038] in /Users/builder/jenkins/workspace/test-mono-mainline/label/osx-i386/mcs/class/corlib/System.Reflection/MonoMethod.cs:309
```

Since the test is only checking if expiring of the cached DNS lookup works, we don't really need to use an external domain name for this as "localhost" works just fine as well and typically doesn't trigger a DNS query which makes the test more reliable against network issues.

@monojenkins merge
2016-06-09 14:35:12 +01:00
Marek Safar 19880afc7a [mcs] Recognize indexer with accessors using different names. Fixes #41602 2016-06-09 14:59:49 +02:00
Marcos Henrich fff8e4e1c5 [runtime] Fixed interruptible wapi_sendfile part2.
Fixed issue where underlying system without HAVE_SENDFILE
would not interrupt while sending a file even when the socket was
set as a non blocking one.
2016-06-09 12:42:15 +01:00
Alexander Köplinger ea4ad81185 [System] Make ServicePointTest.DnsRefreshTimeout test more reliable
We are still seeing quite rare failures of this test:

```
HostEntry should result in the same IPHostEntry object.
  Expected: same as <System.Net.IPHostEntry>
  But was:  <System.Net.IPHostEntry>

+++++++++++++++++++
STACK TRACE:
at MonoTests.System.Net.ServicePointTest.DnsRefreshTimeout () [0x00045] in /Users/builder/jenkins/workspace/test-mono-mainline/label/osx-i386/mcs/class/System/Test/System.Net/ServicePointTest.cs:228
at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
at System.Reflection.MonoMethod.Invoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[] parameters, System.Globalization.CultureInfo culture) [0x00038] in /Users/builder/jenkins/workspace/test-mono-mainline/label/osx-i386/mcs/class/corlib/System.Reflection/MonoMethod.cs:309
```

Since the test is only checking if expiring of the cached DNS lookup works, we don't really need to use an external domain name for this
as "localhost" works just fine as well and typically doesn't trigger a DNS query which makes the test more reliable against network issues.
2016-06-09 13:24:13 +02:00
Alexander Köplinger 2774428b2d Merge pull request #3138 from akoeplinger/fix-win
[metadata] Fix Windows gcc build break
2016-06-09 11:52:05 +02:00
Marek Safar 4021e61ab1 [mcs] Bump ikvm to fix assembly unification rules 2016-06-09 10:30:40 +02:00
Alex Rønne Petersen 738521b8cf [arm] Correctly detect hardware features when running as arm32 on arm64 hardware. 2016-06-09 07:22:57 +02:00
Alexander Köplinger 13f87866a9 [metadata] Fix Windows gcc build break
After 680fe21e69 it failed with:

```
coree.c: In function '_CorExeMain':
coree.c:200:2: error: implicit declaration of function 'mono_runtime_run_main_checked' [-Werror=implicit-function-declaration]
  mono_runtime_run_main_checked (method, argc, argv, &error);
  ^
[...]
Makefile:2137: recipe for target 'libmonoruntime_la-coree.lo' failed
make[3]: *** [libmonoruntime_la-coree.lo] Error 1
```
2016-06-09 02:53:48 +02:00
Mark Probst 37bb54b503 [sgen] Scatterplot option for gcpauseviz. 2016-06-08 16:03:14 -07:00
Vlad Brezae eaa2627cf5 [sgen] Exit the critical section also on the slowpath of managed allocators
We were not exiting the critical section on this code path. This was leading to hangs at stw since the native code would take locks when compiling the code.
2016-06-09 01:50:51 +03:00
Vlad Brezae b136605a73 [sgen] Don't try to stop a stopped world
On domain unload we were calling sgen_perform_collection even though we had a stopped world, when finishing a running concurrent collection.
2016-06-09 01:49:16 +03:00
Rodrigo Kumpera 916fb1aa3e Merge pull request #3135 from kumpera/enable_conc_gc_on_mainline_archs
[jenkins] Make the concurrent GC the default on mainline archtectures.
2016-06-08 15:33:27 -07:00
Rodrigo Kumpera a0866bdd34 [jenkins] Make the concurrent GC the default on mainline archtectures. 2016-06-08 15:12:47 -07:00
Alexander Köplinger d74cf1d5dc Merge pull request #3090 from alexanderkyte/remove_deprecated_assertions
[mobile_static] Remove deprecated assertions
2016-06-08 23:04:00 +02:00
Rolf Bjarne Kvinge 627fe81dc1 [corlib] Fix tests for watchOS. (#3131) 2016-06-08 16:46:11 -04:00
Zoltan Varga 0652b7069c [llvm] Enable support for the atomic store intrinsics when running with llvmonly. 2016-06-08 14:58:15 -04:00
Alex Rønne Petersen 91734968b8 Merge pull request #3117 from alexrp/master
Fix a few socket test failures on Android
2016-06-08 18:04:48 +02:00
Aleksey Kliger dae1630a21 [runtime] Okay to raise MonoError in thread start functions.
They just trigger the unhandled exception handlers.
2016-06-08 10:55:14 -04:00
Aleksey Kliger (λgeek) 4cf9ffd6cf Merge pull request #3093 from lambdageek/dev/monoerror-exec
[runtime] Mark mono_runtime_{run,exec}_main external only.
2016-06-08 10:35:46 -04:00
Alex Rønne Petersen 57e8af467a [sockets] Correctly report that Linux supports double binding for UDP, even on old kernels. 2016-06-08 15:40:12 +02:00
Marek Safar 7800c71e39 [mcs] Improve betterness changes in b12385e9fd 2016-06-08 15:26:32 +02:00
Marek Safar fed1f25cab [System] Fixes compiler warning 2016-06-08 15:26:31 +02:00
Alex Rønne Petersen 5893ae1883 [System] Make SocketAsyncTest.SendAsync give more helpful failures. 2016-06-08 15:04:18 +02:00
Alexander Köplinger d3c2d9c5f4 [build] Add llvm folder to SUBDIRS/DIST_SUBDIRS
This ensures all the right files are packaged in the tarball.
2016-06-08 14:05:50 +02:00
Alexander Köplinger 7b20c1b851 Merge pull request #3122 from akoeplinger/fix-41530
[System] Make TimerTest.EnabledInElapsed more reliable
2016-06-08 12:47:41 +02:00
Marcos Henrich 02f5cd35f2 Merge pull request #3120 from esdrubal/syscall_details
Fixes SendAsyncFile flaky failures
2016-06-08 09:03:20 +01:00
Zoltan Varga 5df50b299a [runtime] Only print out the value of MONO_EXTRA_CONFIGURE_FLAGS when it is set. 2016-06-08 03:05:16 -04:00
Rodrigo Kumpera 28b0808a7c Merge pull request #3118 from kumpera/fix_getname
[corlib] Handle user Assembly subclass and Assembly::GetName.
2016-06-07 17:22:55 -07:00
Alexander Köplinger bab393e095 [System] Make TimerTest.EnabledInElapsed more reliable
We were seeing intermittent failures on devices like:

```
	[FAIL] TimerTest.EnabledInElapsed :   #1 loss of events
  Expected: True
  But was:  False

		  at MonoTests.System.Timers.TimerTest.EnabledInElapsed () <0x33b168 + 0x0014f> in <filename unknown>:0
		  at (wrapper managed-to-native) System.Reflection.MonoMethod:InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&)
		  at System.Reflection.MonoMethod.Invoke (System.Object , BindingFlags , System.Reflection.Binder , System.Object[] , System.Globalization.CultureInfo ) <0x66d400 + 0x000b7> in <filename unknown>:0
```

Since OS scheduling and GCs can influence the exact timing of the timer intervals sleeping for 200ms is likely just too short.
Instead of bumping the timeout, I decided to rewrite the test to not rely on Thread.Sleep ().
I also added another test which verifies setting AutoResetEvent=false stops the timer event from firing after the first one,
which was implicitly tested before by the other test.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=41530
2016-06-08 01:52:59 +02:00
Rodrigo Kumpera 968540b28b Merge pull request #3114 from alexanderkyte/mono_conf_gc
[runtime] Add configuration for the default sgen gc mode
2016-06-07 15:44:03 -07:00
Alexander Köplinger cd12b91372 Merge pull request #3112 from akoeplinger/test-runner-nofile
[test-runner] Write stdout/stderr into StringBuilder instead of an intermediate file
2016-06-08 00:18:39 +02:00
Miguel de Icaza 842da704cc More updates 2016-06-07 17:53:46 -04:00
Rodrigo Kumpera 36116e1de4 [corlib] Handle user Assembly subclass and Assembly::GetName.
Remove UnprotectedGetName and replace with overriding of GetName.

dotnet throws NIE if you subclass Assembly and call GetName on it.
We hard crashed.
2016-06-07 14:12:39 -07:00
Alexander Köplinger 9e7182c7d6 Fix make dist
It got broken when the versions.py file was moved around in d110f52670.
Also add the new locations to EXTRA_DIST so they get distributed too.
2016-06-07 22:44:54 +02:00
Rodrigo Kumpera 19daae6f46 Merge pull request #3119 from kumpera/fix-getname-and-shadowcopy
[corlib] Take shadow copying when computing CodeBase in Assembly::GetName.
2016-06-07 12:51:27 -07:00
Aleksey Kliger (λgeek) 022ebf4501 Merge pull request #3082 from alexanderkyte/no_alloc_klass_error
[runtime] Set klass-error-based MonoError state without allocating
2016-06-07 15:23:17 -04:00
Alexander Kyte e5ccb30a0c [mobile_status] Fix nullable type ambiguity that nunit-lite complains about 2016-06-07 14:56:52 -04:00
Alexander Kyte cd9dfae952 [mobile_static] Remove use of CollectionAssert, missing in nunit-lite 2016-06-07 14:56:51 -04:00
Alexander Kyte ac19ad8a47 [mobile_static] Remove uses of deprecated Assertion.cs nunit helper. 2016-06-07 14:56:51 -04:00
Rodrigo Kumpera 028fe45243 Merge pull request #3110 from BrzVlad/fix-complex-conc-scan
[sgen] Fix concurrent scan of complex objects
2016-06-07 11:38:27 -07:00
Alex Rønne Petersen 4d9acdafed [Socket] Check for SocketOptionLevel.Socket before checking for SocketOptionName.ReuseAddress.
Without doing this, the check would consider a valid option name like
IpTimeToLive to be the same as ReuseAddress, as they share the same enum
value.

Fixes SocketTest.TtlChange and SocketTest.UdpMulticasTimeToLive on Android and
other platforms that don't support ReuseAddress.
2016-06-07 20:21:00 +02:00
Alexander Köplinger 5c1615a27d Merge pull request #3124 from mono/revert-2734-master
Revert "Enhance log tracing"
2016-06-07 18:45:29 +02:00
Alexander Köplinger 565c6ac080 Revert "Enhance log tracing" 2016-06-07 18:45:09 +02:00
Alexander Kyte 16c5c2e6ed [runtime] Add environment variable to pass additional configure options 2016-06-07 12:29:39 -04:00
Alexander Kyte c0d56727c8 [runtime] Add new configure option for default sgen GC mode 2016-06-07 12:29:23 -04:00
Zoltan Varga 41784378fb [amd64] Fix an off-by-one in the dyn call code. 2016-06-07 12:17:08 -04:00
Zoltan Varga d110f52670 Llvm submodule (#3108)
* Move the versions.mk infrastructure to scripts/submodules so it can be used elsewhere too.

* Add a conditional submodule for llvm.

* Fix commit messages emitted by the bump- targets.

* Use a anonymous git url for llvm.
2016-06-07 10:46:33 -04:00
Marcos Henrich 11743177c7 [runtime] Fixed interruptible wapi_sendfile.
Before closing a socket we try to interrupt and wait for all socket
pending system calls to return. For that we set the socket as non
blocking which makes the system calls to return with EAGAIN\EWOULDBLOCK.

This issue was caught by System.Net.Sockets.SocketTest.SendAsyncFile
that was intermittently failing, we were only able to reproduce it while
running multiple test suites in parallel. We now can say that it only failed when
the the socket was closed and the sendfile was waiting for the OS to
allocate enough resources to send the file.

This was fixed by changing wapi_sendfile to return on EAGAIN.
2016-06-07 14:25:04 +01:00
Marcos Henrich 91c68de23f [System] Improved "Could not abort" exception.
Stack traces of blocked threads are now displayed on the exception.

The threads stacktraces are only stored when MONO_TESTS_IN_PROGRESS env
var is set to yes.
2016-06-07 14:01:00 +01:00
Alexander Kyte 07bb23a4d4 [runtime][mobile_static] Add flag for rgctx_fetch_trampolines and use it (#3088)
* [runtime] Add commandline option for rgctx fetch trampolines.

* [mobile_static] Increase the number of trampolines
2016-06-07 07:44:40 -04:00
lateralusX aaf8b8dbbf Smaller adjustments based on PR feedback. 2016-06-07 11:35:02 +02:00
Zoltan Varga 97634ecfae [runtime] Call mono_class_init () for classes in mono_class_is_subclass_of (). Fixes #41466. 2016-06-07 04:08:46 -04:00
Rodrigo Kumpera 72f2128755 [corlib] Take shadow copying when computing CodeBase in Assembly::GetName. 2016-06-06 23:36:32 -07:00
Alex Rønne Petersen 614e1a10e6 Merge pull request #3116 from alexrp/master
Some improvements to the profiler makefile
2016-06-07 03:35:36 +02:00
Mark Probst 326caca175 [sgen] Make gcpauseviz histograms more meaningful.
There were too many bins, because the x axis was not logarithmic, and
there were no meaningful labels.
2016-06-06 16:36:38 -07:00
Mark Probst 34c779eed0 [sgen] Fix gcpauseviz.
It didn't detect starts of concurrent collections anymore because of how
the binary protocol outputs it.
2016-06-06 16:36:38 -07:00
Alex Rønne Petersen c5a914bcbc [profiler] Don't install the coverage suppression file if the profiler is disabled. 2016-06-07 00:49:04 +02:00
Alex Rønne Petersen fa8cfb0254 [profiler] Don't run the test suite when the profiler is disabled.
Also clean up the makefile logic surrounding tests a bit.
2016-06-07 00:44:58 +02:00
Alexander Köplinger a5beea4126 Merge pull request #3113 from akoeplinger/boehm-fixes
[ci] Turn off Boehm on Windows x64 gcc build
2016-06-06 23:44:35 +02:00
Zoltan Varga 1197df8e64 [offsets-tool] Generate offsets for SgenClientThreadInfo. 2016-06-06 16:48:02 -04:00
Vlad Brezae b940b99c81 [sgen] Fix define argument
The code worked by accident because the function in which the define was expanded had an argument with the name desc.
2016-06-06 23:32:14 +03:00
Vlad Brezae feeda9992c [sgen] Fix race between complex descriptor allocation and complex object scanning
When we allocate the complex descriptor for a new type we might have the concurrent marker scan objects. While the concurrent marker scans the bitmap for a complex object, which resides in the complex_descriptor array, another thread might allocate a new complex descriptor, thus reallocate the complex_descriptor array, which would lead to corruption of the bitmap used by the concurrent marker.

We reuse the SgenArrayList which never reallocates, using instead a list of exponentially increasing arrays.
2016-06-06 23:32:12 +03:00
Alexander Köplinger 6e1443d029 Only define Boehm variables in configure.ac when it is enabled
Fix the message that is printed in the configure summary at the end to contain only "sgen" when Boehm is disabled.
2016-06-06 21:18:45 +02:00
Alexander Köplinger 1311dd46a8 [ci] Turn off Boehm on Windows x64 gcc build
It was never supported there, turn it off to fix the build on Jenkins.
2016-06-06 21:07:07 +02:00
Zoltan Varga d631febd56 [amd64] Fix a loop variable reuse in a58c2ef804. 2016-06-06 15:04:11 -04:00
Aleksey Kliger (λgeek) 150cd3f9f1 Merge pull request #3100 from lambdageek/dev/monoerror-exns
[runtime] Pass MonoError to exception creation utilities
2016-06-06 14:39:05 -04:00
Vlad Brezae 248ef6ea73 [sgen] Make sure we will scan the bits correctly for complex objects 2016-06-06 21:07:21 +03:00
Vlad Brezae c9d37d3686 [sgen] Add missing memory type description 2016-06-06 21:07:20 +03:00
Aleksey Kliger (λgeek) 395888e241 Merge pull request #3104 from lambdageek/dev/monoerror-resolve_vcall
[llvm] Raise MonoError using mono_llvm_throw_exception
2016-06-06 14:01:44 -04:00
Zoltan Varga 5092923485 [jit] Fix the emission of Selector.GetHandle () implementation to avoid the creation of string objects, which could cause GCs don't work in a cross compiler. Fixes #41431. 2016-06-06 13:22:18 -04:00
Alexander Köplinger 0d88c053bf [test-runner] Write stdout/stderr into StringBuilder instead of an intermediate file
We don't need to write out and then read back in the contents. Additionally, this will prevent
an unhandled exception we've seen on Jenkins due:

```
Unhandled Exception:
System.IO.IOException: Sharing violation on path /media/ssd/jenkins/workspace/test-mono-mainline-linux/label/debian-8-arm64/mono/tests/finalizer-wait.exe.stdout
  at System.IO.FileStream..ctor (System.String path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, System.Int32 bufferSize, System.Boolean anonymous, System.IO.FileOptions options) <0x7f7eb4a740 + 0x00650> in <filename unknown>:0
  at System.IO.FileStream..ctor (System.String path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, System.Int32 bufferSize, System.IO.FileOptions options, System.String msgPath, System.Boolean bFromProxy, System.Boolean useLongPath, System.Boolean checkHost) <0x7f7eb4a620 + 0x00053> in <filename unknown>:0
  at (wrapper remoting-invoke-with-check) System.IO.FileStream:.ctor (string,System.IO.FileMode,System.IO.FileAccess,System.IO.FileShare,int,System.IO.FileOptions,string,bool,bool,bool)
  at System.IO.StreamReader..ctor (System.String path, System.Text.Encoding encoding, System.Boolean detectEncodingFromByteOrderMarks, System.Int32 bufferSize, System.Boolean checkHost) <0x7f7e9b2170 + 0x000f3> in <filename unknown>:0
  at System.IO.StreamReader..ctor (System.String path, System.Text.Encoding encoding, System.Boolean detectEncodingFromByteOrderMarks, System.Int32 bufferSize) <0x7f7e9b2120 + 0x00037> in <filename unknown>:0
  at System.IO.StreamReader..ctor (System.String path, System.Boolean detectEncodingFromByteOrderMarks) <0x7f7e9b2040 + 0x0003b> in <filename unknown>:0
  at System.IO.StreamReader..ctor (System.String path) <0x7f7e9b2010 + 0x0001f> in <filename unknown>:0
  at (wrapper remoting-invoke-with-check) System.IO.StreamReader:.ctor (string)
  at System.IO.File.ReadAllText (System.String path) <0x7f7eb48c70 + 0x0003b> in <filename unknown>:0
  at TestRunner.DumpPseudoTrace (System.String filename) <0x7f7cfc6450 + 0x00023> in <filename unknown>:0
  at TestRunner.Main (System.String[] args) <0x7f8128b770 + 0x01ed3> in <filename unknown>:0
```
2016-06-06 18:09:14 +02:00
Alexander Köplinger 6c74957217 [test-runner] Print timeout value when test times out
This is useful when multiple timeouts are in place e.g. like in the runtime testsuite.
2016-06-06 18:06:06 +02:00
Marek Safar 5ed50ba7e3 Merge pull request #3111 from directhex/sed-before-sign
Move call to sn.exe to *after* cil-stringreplacer.exe
2016-06-06 18:01:19 +02:00
Aleksey Kliger (λgeek) 883a0ae745 Merge pull request #2734 from nealef/master
Enhance log tracing
2016-06-06 12:00:47 -04:00
Jo Shields 439f0bea1f Move call to sn.exe to *after* cil-stringreplacer.exe
This makes sure mscorlib.dll still has a valid signature (fixes nightly builds on Linux)
2016-06-06 16:57:24 +01:00
Rodrigo Kumpera 02e48b67ba Merge pull request #3070 from kumpera/runtime-handles
Local handles initial drop
2016-06-06 08:42:34 -07:00
Rodrigo Kumpera 60f85567e2 Merge pull request #3083 from alexrp/gc-pointless-memory-barrier
[sgen] Remove a pointless memory barrier from the middle of the managed allocator.
2016-06-06 08:37:39 -07:00
Marek Safar 88217fa1ad [System] Override SupportsHeaders in all WebResponse overrides 2016-06-06 16:59:33 +02:00
Zoltan Varga 43914d3d0f [amd64] Enable dyncall tests on amd64. 2016-06-06 09:52:28 -04:00
Zoltan Varga a58c2ef804 [amd64] Support stack args in dyn calls. 2016-06-06 09:50:31 -04:00
Zoltan Varga e54b75c074 [amd64] Handle ArgValuetypeAddrInIReg in dyncalls. 2016-06-06 07:39:36 -04:00
Aleksey Kliger (λgeek) 42975530c3 [mini] Set pending MonoError in mono_vcall_trampoline (#3107) 2016-06-04 05:02:48 -04:00
Rodrigo Kumpera 5286dfc857 Remove unused header. 2016-06-03 14:29:23 -07:00
Rodrigo Kumpera ea865faee1 [coop] New local handles implementation.
This is the initial code drop of a new handles implementation.

It differs from the previous one is a few ways:

- It keeps a separate stack of handles which is shared by all "arenas".
This eliminates malloc in the majority of the cases without the need for any tuning

- Custom gc scanning code for the handles stack.
The original implementation registered the chunks as a GC roots. Which is a terribly
slow operation as it takes the GC lock.

Instead of allocating a new handle arena for each icall, we compute a stack mark,
which is the position in the handles stack at icall entry. On exit, we simply restore that
position, which is just a couple of stores.

Since the stack is implemented using arraylets, addressed are stable in the face of
expansion.

Only the typed handles function/macros are in as having both typed and untyped handles
adds extra complexity for no clear value.

The macros only handle what was needed to port a sizeable chunk of locales.c.

This commit just sets the stage for the feature, there's quite some work left
before we can start using it, as it can be seen in the big TODO in handle.c
2016-06-03 14:28:05 -07:00
Rodrigo Kumpera e81430a7d6 [sgen] Fix scan thread data job to set ops so it can do precise scanning. 2016-06-03 13:05:47 -07:00
Rodrigo Kumpera 3da98be66a [mono-error] Fix error_init macro to work with MonoError pointers. 2016-06-03 13:05:47 -07:00
Aleksey Kliger 7fe8716cc9 [llvm] Propagate MonoError out of mini_resolve_imt_method
To the enclosing llvm jit icalls
2016-06-03 15:00:00 -04:00
Neale Ferguson e29996786e Use %Y-%m-%d %H:%M:%S for Windows log message header 2016-06-03 13:33:23 -04:00
Andi McClure 28d9e844c0 Merge pull request #3040 from xmcclure/debugger-step-recursive
Debugger stepping does not understand recursion (bug 38025)
2016-06-03 13:08:23 -04:00
Miguel de Icaza 638f79df43 [genproj] Update project files 2016-06-03 12:42:16 -04:00
Aleksey Kliger 7a1baa941d [jit] Pass MonoError to resolve_vcall 2016-06-03 12:38:58 -04:00
Marek Safar 9fd9c7c851 [System] Flush few colliding changes 2016-06-03 18:04:33 +02:00
Alexander Kyte 356d3c3e25 [runtime] Use new mono_error_set_for_class_failure where applicable.
We were seeing an issue where attempts to create the MonoClass for an
exception in a no-exec context was causing failure. No-exec will forbid
the constructor call. Our solution was to realize that there was no
need to allocate an exception, as MonoError could already encode the
errors.
2016-06-03 11:24:33 -04:00
Alexander Kyte 7a29fbf203 [runtime] Make helper to set MonoError directly from MonoClass error 2016-06-03 11:24:32 -04:00
Neale Ferguson c41ea7babe Correct typo 2016-06-03 10:56:34 -04:00
Neale Ferguson 9100c240c5 Correct for widechar on Windows 2016-06-03 10:34:35 -04:00
Marek Safar 4a2bb8c261 [mcs] Fixes NRE during error reporting 2016-06-03 16:21:46 +02:00
Marek Safar 4ee86125fb [System] Remove duplicate file entry 2016-06-03 16:21:46 +02:00
Neale Ferguson b5ec75b264 Several corrections thanks to Johan Lorensson 2016-06-03 09:57:11 -04:00
Alexander Köplinger 6277093677 [WinForms] Fix build broken by 5d54803af7 2016-06-03 15:13:57 +02:00
Jonathan Chambers fbe5fc6e2a Correcty initialize image ref_count. Ensures image is correctly unloaded during appdomain unload. (#3084) 2016-06-03 09:13:41 -04:00
Marek Safar ef82a75735 Merge pull request #3102 from alexrp/master
[System] Add back IWebProxyScript to the mobile profile.
2016-06-03 11:04:40 +02:00
Alex Rønne Petersen eb1072dc1c [System] Add back IWebProxyScript to the mobile profile. 2016-06-03 10:09:00 +02:00
Jiří Volejník 5d54803af7 SWF - Fixed exiting modal runloop. (#2980)
Fixes a bug in exiting modal runloop that caused not really exiting it
(not calling XplatUI.SetModal(..., false).

It caused issues with menu, for example, if you first ran a modal
dialog (a wizard), and then you started the application.
2016-06-03 03:09:24 -04:00
Marek Safar 4f252f1492 Merge pull request #3099 from marek-safar/rs-Semaphore
[System] Semaphore from referencesource
2016-06-03 08:23:12 +02:00
Alexander Kyte 27e1646959 [mobile_static] Removed use of StringAssert nunit helper. 2016-06-02 19:49:45 -04:00
Ludovic Henry bea97b9d05 [sgen] Use raw mutex for pin_queue_mutex as it's only used during a collection 2016-06-02 23:25:31 +02:00
Ludovic Henry d462b209dd [coop] Reuse local info variable for polling
This would lead to a crash when unregistering the thread from the currnt MonoThreadInfo* destructor, as `mono_thread_info_current_unchecked` would return NULL. This would trigger an infinite loop in `mono_threads_enter_gc_safe_region_unbalanced_with_info`.
2016-06-02 23:25:31 +02:00
Ludovic Henry 5ce106b096 [marshal] Fix unused variable warning 2016-06-02 23:25:31 +02:00
Ludovic Henry d5cf286306 [threads] Make mono_thread_detach_if_exiting return if it detached 2016-06-02 23:25:31 +02:00
Ludovic Henry 12e53bcd36 [coop] Use mono_thread_info_is_current in checked build 2016-06-02 23:25:31 +02:00
Ludovic Henry 299f33e9b9 [coop] Remove unecessary assertion 2016-06-02 23:25:31 +02:00
Ludovic Henry fa65f20cb6 [coop] Switch to GC unsafe state in SIGILL signal handler as it may throw an exception 2016-06-02 23:25:31 +02:00
Ludovic Henry f303f385fc [runtine] We should always ignore SIGPIPE signal 2016-06-02 23:25:31 +02:00
Ludovic Henry b89cb4c62d [coop] Ensure GC unsafe state when throwing exception 2016-06-02 23:25:31 +02:00
Ludovic Henry e5f46c5360 [coop] Switch to GC safe around pthread_join 2016-06-02 23:25:31 +02:00
Ludovic Henry f90ff09854 [coop] Do not pass current thread to mono_threads_enter_gc_unsafe_region_cookie 2016-06-02 23:25:31 +02:00
Ludovic Henry c847599f8b [coop] Fix state transition when unregistering the thread
unregister_thread is the destructor for the current MonoThreadInfo* TLS key, meaning that when in this function, calling mono_thread_info_current_unchecked will always return NULL.
2016-06-02 23:25:31 +02:00
Ludovic Henry e53d878fb1 [coop] Make GC safe/unsafe unbalanced transitions public
This is needed by Xamarin.iOS for unbalanced transitions, for example aroung a ObjC @throw.
2016-06-02 23:25:31 +02:00
Ludovic Henry ab7f366947 [coop] Do not include mono-threads-coop.h and mono-threads-api.h in mono-threads.h
This leads to circular dependency between them, while mono-threads.h does not depends on the other 2.
2016-06-02 23:25:31 +02:00
Ludovic Henry d015b99f51 [coop] Do not allow transition on not-attached, not-current and not-live thread 2016-06-02 23:25:31 +02:00
Ludovic Henry 22eb4a02c7 [coop] Remove unecessary GC unsafe transition 2016-06-02 23:25:31 +02:00
Ludovic Henry f3a4be103b [marshal] Fix setting of last error for P/Invoke
On Unix, errno value might change between the native call and the call to mono_marshal_set_last_error, if we exit the gc safe region. We need to ensure that it's done right after the native call.
2016-06-02 23:25:31 +02:00
Ludovic Henry d07f4ec67b [checked-build] Fix warning 2016-06-02 23:25:31 +02:00
Ludovic Henry 5c16034406 [coop] Remove DoneBlockingAborted state transition
This state transition would only be possible in case something went wrong. It's better to fix where this issue comes from.
2016-06-02 23:25:31 +02:00
monojenkins f1dd6fe748 Merge pull request #2881 from alexrp/gc-sample-managed-alloc
[gc] Register a critical region when executing managed allocators.

Previously, if we stopped a thread and it had a stack looking like this:

    ...
    profiler_signal_handler
    <signal handler called>
    managed_allocator
    ...

We would fail to identify the fact that we've just interrupted a thread that's
in a managed allocator (uninterruptible code) because we only look at the very
latest instruction pointer of the thread, which will be pointing into
profiler_signal_handler or some other function called by it. So we would
happily continue along with the STW process and proceed to doing the actual GC,
where we would see a broken heap.

We could solve this by unwinding the stack and checking all frames, but that's
complicated and error-prone. Instead, register a critical region while the
managed allocator runs. This way, if we don't identify it by instruction pointer, we
will identify it by the fact that the thread is in a critical region.
2016-06-02 21:45:26 +01:00
Alexander Köplinger b2cf10659d Merge pull request #3066 from alexanderkyte/pedump_sgen
[runtime] Replace pedump boehm dependency with sgen dependency
2016-06-02 22:00:38 +02:00
Aleksey Kliger 1a3d55d848 [runtime] Mark mono_exception_from_token_two_strings external only
Runtime should use mono_exception_from_token_two_strings_checked
2016-06-02 15:56:02 -04:00
Aleksey Kliger aa0c3ca98f [runtime] Mark mono_exception_from_name_two_strings external only.
Runtime should use mono_exception_from_name_two_strings_checked
2016-06-02 15:56:02 -04:00
Marek Safar e76193b5b2 [System] Semaphore from referencesource 2016-06-02 21:33:22 +02:00
Neale Ferguson 583d1a2580 Correct use of localtime() in Win32 2016-06-02 15:33:12 -04:00
Neale Ferguson 927a3d1cff Use localtime for Win32 and localtime_r for others 2016-06-02 14:40:05 -04:00
Neale Ferguson b7ba3d54bd Correct syntax error and G_LOG_xxx identifier 2016-06-02 14:09:26 -04:00
Neale Ferguson c53c93791f Correct use of Windows APIs 2016-06-02 13:40:15 -04:00
Neale Ferguson 6db4cc54f0 Use correct APIs for Windows; Remove sys/time.h 2016-06-02 13:14:56 -04:00
Neale Ferguson c5327b6a02 Correct conditional compilation & move logger source files to correct place 2016-06-02 11:59:45 -04:00
Aleksey Kliger 680fe21e69 [runtime] Mark mono_runtime_run_main external only.
Runtime should use mono_runtime_run_main_checked or mono_runtime_try_run_main
2016-06-02 10:42:46 -04:00
Aleksey Kliger 985a6bb043 [runtime] Mark mono_runtime_exec_main external only.
Runtime should use mono_runtime_exec_main_checked or mono_runtime_try_exec_main
2016-06-02 10:42:46 -04:00
Aleksey Kliger (λgeek) 79451d22e7 Merge pull request #3087 from lambdageek/dev/monoerror-mono_object_to_string
[runtime] Mark mono_object_to_string external only.
2016-06-02 10:31:29 -04:00
Marek Safar f965a4e5db [System] Internal connectionpool from referencesource 2016-06-02 16:19:42 +02:00
Alex Rønne Petersen 817f874aac Merge pull request #3096 from alexrp/master
[bcl] Avoid ObjectDisposedException in EndPointListener.
2016-06-02 15:11:51 +02:00
Marek Safar 7e4adb9ef4 [corlib] Fixes mobile tests 2016-06-02 14:40:47 +02:00
Marek Safar 8f6567bebf Merge pull request #3097 from rolfbjarne/mono-api-info-compare-generic-method-parameters
[mono-api-info] Take number of generic parameters into account when comparing methods.
2016-06-02 13:11:16 +02:00
Rolf Bjarne Kvinge 624f29b583 [mono-api-info] Take number of generic parameters into account when comparing methods. 2016-06-02 12:12:35 +02:00
Zoltan Varga 164c74028e [arm] Return structures with sizes up to 16 bytes in int registers on watchos. Fixes #41393. 2016-06-02 06:01:40 -04:00
Alex Rønne Petersen d9fc8f866a [bcl] Avoid ObjectDisposedException in EndPointListener.
This fixes a regression introduced in 123aaa5db0.
We would sometimes see an ObjectDisposedException when calling AcceptAsync ()
because that patch removed the try-catch around it.
2016-06-02 11:27:38 +02:00
Marek Safar 20d025bb28 Merge pull request #3094 from mbrophy1/master
Add missing type forwarder for System.Diagnostics.Tracing.EventSource…
2016-06-02 09:51:50 +02:00
Alexander Kyte 1c99d720d6 Merge pull request #3095 from alexanderkyte/typespec_cache_fix
[runtime] Don't free null cache hash table in aot compiler
2016-06-01 18:42:38 -04:00
Alexander Kyte 62ba7ca6b4 [runtime] Don't free null cache hash table in aot compiler 2016-06-01 18:39:35 -04:00
Andi McClure 34d0fdb5a3 Halve the stack depth for both the new single step tests 2016-06-01 18:04:35 -04:00
Miguel de Icaza ed75412ec1 [genproj] More updates to the project files, getting closer, down to 5 errors 2016-06-01 16:18:11 -04:00
Matthew Brophy 9ebb048e80 Add missing type forwarder for System.Diagnostics.Tracing.EventSourceSettings. ASP.net Core 1.0 RC2 apps will not run against mono without this. 2016-06-01 21:17:29 +01:00
Aleksey Kliger 598b8290de [runtime] Comment external only functions that call mono_error_raise_exception 2016-06-01 15:39:55 -04:00
Aleksey Kliger bcbd0ac0c0 [runtime] Mark mono_object_to_string external only.
Runtime should use mono_object_to_string_checked and mono_object_try_to_string.
2016-06-01 15:39:46 -04:00
Marek Habersack 9d18dc706c Xamarin.Android test suite updates
Xamarin.Android internal test suite takes advantage of the BCL tests
in Mono, so far their inclusion was a manual process and this commit
fixes it. A set of source inclusion and exclusion lists is added
and a handful of code fixes to make them compile on Xamarin.Android
2016-06-01 20:35:51 +02:00
Marek Safar 29556e2cd8 [corlib] Disable even more cas in mobile 2016-06-01 20:06:54 +02:00
Alexander Kyte 7bbf991bff [runtime] Replace pedump boehm dependency with sgen dependency 2016-06-01 13:04:19 -04:00
Aleksey Kliger (λgeek) 3f435390aa Merge pull request #3081 from lambdageek/coop-no-prof
[coop] Disable profiler tests if coop is enabled
2016-06-01 12:55:58 -04:00
monojenkins 4e928f6338 Merge pull request #3086 from esdrubal/master
[System] Fixes socket async exception.

SendAsyncFile uses StartSocketServer to start a server and at the same
time begins to accept a client socket. The issue is that when
the accept callback is called SendAsyncFile already closed the socket.

Fixed race condition by moving StartSocketServer and ReceiveCallback
logic into SendAsyncFile, and by using a new MRE to ensure that the
client receives all the data before the server is closed.

Fixes [#41264](https://bugzilla.xamarin.com/show_bug.cgi?id=41264)
2016-06-01 17:25:11 +01:00
Marek Safar ca82b187d2 [corlib] Disable more CAS code 2016-06-01 18:01:10 +02:00
Aleksey Kliger 830f7eec99 [coop] Disable profiler tests if coop is enabled 2016-06-01 10:25:33 -04:00
Marcos Henrich 0693884580 [System] Fixes socket async exception.
SendAsyncFile uses StartSocketServer to start a server and at the same
time begins to accept a client socket. The issue is that when
the accept callback is called SendAsyncFile already closed the socket.

Fixed race condition by moving StartSocketServer and ReceiveCallback
logic into SendAsyncFile, and by using a new MRE to ensure that the
client receives all the data before the server is closed.

Fixes #41264
2016-06-01 15:08:05 +01:00
Marek Safar d76164a203 [mcs] Use only mcs specific assembly references resolver. Fixes #29189 2016-06-01 13:41:48 +02:00
lateralusX 21e166b9ae Fix for non GCC win x64 calling convention when passing empty structs over pinvoke.
Standard C and C++ doesn't allow empty structs, empty structs will always have a
size of 1 byte. GCC have an extension to allow empty structs,
https://gcc.gnu.org/onlinedocs/gcc/Empty-Structures.html. This cause a
little dilemma since runtime build using none GCC compiler will not be
compatible with GCC build C libraries and the other way around. On platforms
where empty structs has size of 1 byte it must be represented in call and cannot
be dropped.

Libraries build using for example MSVC failed pinvoke call when empty
structs where used in pinvoke2.cs tests. The problem was that current
implementation dropped value types of size 0, eliminating them from the
call. Since MSVC implements C/C++ standard regarding empty structs (no extension used),
the function expected the parameter to be present, even if was not used.
This became a problem if the empty struct ended up in one of the 4 first
parameters (backed by registers) since if excluded, wrong parameter gets
into wrong registers (the same will apply to stack slots as well). For example,
a C signature like this, (int a, EmptyStruct es, int b) will get lowered to the
following on MSVC win x64, a -> rcx, es -> rdx and b -> r8, but since caller
eliminated es from the call, the register assignment from the caller was
a -> rcx and b -> rdx causing a violation of the calling convention and
error in callee.

The fix is to make sure that empty structs are still represented on none GCC
compilers on windows x64 (MSVC), since they must be represented in the call
to pinvoked methods. Fix will also use a const value of 0 to represent the value
passed as the struct instead of loading a value from stack into register/stack slot,
this is inline with the value the .NET runtime passes to pinvoked method. The reason
why we use a 0 instead of loading from stack is because a struct of size 0 is not explicitly
represented on stack and will have garbage data if loaded. Since it’s an empty struct value
type there is no need to load anything, just represent it as 0 in the register/stack slot passed
to caller.

There is also a case when returning an empty struct from a pinvoked method. Result will be returned
as 0 in RAX by MSVC compiled libraries (or whatever value stored in the 1 byte representation).
Since we have similar issues as above with empty structs of size 0 not explicitly represented on the
stack, the store will be eliminated and not written back to stack by caller since an empty struct doesn’t
represent any unique data.

Calling convention for managed->managed code is kept intact since it is working as expected
handling the case with empty structs as input and return values.

With fix all pinvoke2.cs tests now pass running on Windows x64 JIT.
2016-06-01 10:33:22 +02:00
Marek Safar 3c2c4168e0 [mcs] Adjust correctly newline counter inside pragma warning 2016-06-01 10:03:10 +02:00
Marek Safar 827bc97d5d [System] Fixes bootstrap build with old mcs 2016-06-01 10:03:09 +02:00
Zoltan Varga 6e36e18c92 [arm] Pass structures larger than 16 bytes by ref on watchos. Fixes #41393. 2016-06-01 03:28:51 -04:00
Alex Rønne Petersen 50c3c48143 [sgen] Remove a pointless memory barrier from the middle of the managed allocator.
This appears to serve no purpose as tlab_next is a thread-local variable. It's
only ever accessed by other threads in order to write to it, not read it. We
also don't do this memory barrier in the native allocation functions.
2016-05-31 23:40:29 +02:00
Alex Rønne Petersen f9ef2ce122 [arm] Don't emit memory barriers for relaxed atomic loads/stores. 2016-05-31 23:40:09 +02:00
Alex Rønne Petersen f0868d79d9 [sgen] Cache the SgenThreadInfo pointer in a local when emitting managed allocators. 2016-05-31 23:40:08 +02:00
Alex Rønne Petersen 755056dd25 [gc] Register a critical region when executing managed allocators.
Previously, if we stopped a thread and it had a stack looking like this:

    ...
    profiler_signal_handler
    <signal handler called>
    managed_allocator
    ...

We would fail to identify the fact that we've just interrupted a thread that's
in a managed allocator (uninterruptible code) because we only look at the very
latest instruction pointer of the thread, which will be pointing into
profiler_signal_handler or some other function called by it. So we would
happily continue along with the STW process and proceed to doing the actual GC,
where we would see a broken heap.

We could solve this by unwinding the stack and checking all frames, but that's
complicated and error-prone. Instead, register a critical region while the
managed allocator. This way, if we don't identify it by instruction pointer, we
will identify it by the fact that the thread is in a critical region.
2016-05-31 23:40:08 +02:00
Miguel de Icaza 9dc91ef0d3 [genproj] Another library works, System.Json.Microsoft 2016-05-31 17:18:13 -04:00
Rodrigo Kumpera 07b2a10491 Merge pull request #3080 from BrzVlad/feature-enable-conc-master
[sgen] Enable concurrent major by default on desktop platforms
2016-05-31 13:58:09 -07:00
Miguel de Icaza dd0b8f31d9 [genproj] support for using prebuilt resources 2016-05-31 16:50:55 -04:00
Andi McClure 42573c7fce Fixes for peer feedback on recursive step patch
Made breakpoint uniqueness test switch to a hash after 8th item added,
consolidated the code that handles the uniqueness test and makes the
breakpoint in one function, fixed style issues.
2016-05-31 16:36:45 -04:00
Miguel de Icaza b078895e89 [genproj] Getting closer to a full build
* Add TODO list
* Use -useSourcePath when building resources, so we do not need to add the explicit extra path
* More updates, now battling resource generation across the board
* Use newlines in the Unix commands to avoid generating things like cs-parser.cs^M
2016-05-31 15:36:59 -04:00
Mark Probst d15602739b Merge pull request #2871 from BrzVlad/feature-conc-sweep-nrs
[sgen] Run sweep concurrently with nursery collections
2016-05-31 11:07:42 -07:00
Mark Probst 9c3b78485a Merge pull request #3019 from schani/fix-major-pinning
Fix major pinning, and cheap pinning stats by default
2016-05-31 11:03:43 -07:00
Marek Safar b12385e9fd [mcs] Add more of undocumented C#6 improved overload resolution 2016-05-31 18:40:50 +02:00
Miguel de Icaza 65b46a6eaf [genproj] Update build files 2016-05-31 12:23:41 -04:00
Miguel de Icaza 4ad48cec41 [mconfig] Remove dependency on build time settings 2016-05-31 12:11:40 -04:00
Jonathan Pryor 8c32f9c042 Merge pull request #2377 from joelmartinez/docs-multiassembly-extension-fix
[mdoc] Extension method crash fix, removes -multiassembly
2016-05-31 12:01:02 -04:00
Neale Ferguson 166a8df8f1 Make log header message consistent 2016-05-31 11:51:23 -04:00
Joel Martinez ff4ab341c3 [mdoc] Extension method crash fix, removes -multiassembly
The tests added during the initial development of the -multiassembly argument failed to test the presence of extension methods;
the result was a crash that occurred when there were extension methods present in multiple assemblies.

This patch addresses the issue by putting a guard clause around the code that adds the extension method to the index.
Tests have been modified accordingly to verify this bug and include extension methods

Additionally, the -multiassembly parameter was removed entirely. This behavior is now triggered by the presence of -apistyle,
which is where support for "multiple assemblies" was meant to work anyways. To review, this is to support cross-platform
development, where you have multiple -- *different* -- assemblies for each platform. These assemblies will share a certain
cross-section of APIs that will be *exactly* the same in each assembly (as opposed to multiple versions of literally the same assembly).
As a result, every member will now contain an individual `AssemblyInfo` tag that also contains the name of the assembly.
2016-05-31 11:48:11 -04:00
Vlad Brezae 40c3b472e6 [sgen] Enable concurrent major by default on desktop platforms 2016-05-31 18:41:06 +03:00
Alexander Köplinger c1bc0f76fd Merge pull request #3078 from akoeplinger/fix-test-exclude-filename
[build] Make exclusion filename consistent between library and test
2016-05-31 17:24:11 +02:00
Aleksey Kliger (λgeek) 82128fe28f Merge pull request #3067 from lambdageek/dev/monoerror-stringy
[runtime] Deal with MonoErrors from string_to_utf8_checked changes
2016-05-31 11:13:53 -04:00
lateralusX 0ef9fdb669 Merge pull request #3059 from lateralusX/jlorenss/win-x64-dyncall-gsharedvt-support
[aot] Added support for GSHAREDVT and DYNCALL on Windows x64 for full AOT builds.
2016-05-31 16:32:40 +02:00
Alexander Köplinger 919edbf2e4 Merge pull request #3076 from akoeplinger/fix-ziptime-offbyone
[WindowsBase] Fix off-by-one error in ZipTime
2016-05-31 16:06:41 +02:00
Alexander Köplinger 07baa1cce4 [WindowsBase] Fix off-by-one error in ZipTime
The date/time struct in zip.h defines the month value as

    uInt tm_mon;            /* months since January - [0,11] */

.NET's DateTime object in turn stores months from 1-12. We didn't
take this into account when passing the values from managed->native
so the month ended up being off by one.

We didn't use this codepath before https://github.com/mono/mono/pull/3036
that's why it didn't show up until now.
2016-05-31 13:55:05 +02:00
Alexander Köplinger 87b1150070 [build] Make exclusion filename consistent between library and test
The test assembly used *.dll.excludes before while the library uses *.dll.exclude.sources.
Make this consistent to reduce confusion.

Also remove corlib_cmp.dll.excludes which is from a profile that no longer exists.
2016-05-31 13:54:04 +02:00
Marek Safar 059d656a9b [System] Fixes build 2016-05-31 13:44:43 +02:00
Marek Safar e8ca290f1e Merge pull request #3075 from knocte/man_bump
[man] bump man's mono version number too (to 4.5.2)
2016-05-31 11:44:36 +02:00
Andres G. Aragoneses 99f7b148e3 [man] bump man's mono version number too (to 4.5.2)
Following this version bump:
https://github.com/mono/mono/commit/069cea3712a5bd4959e505260cdc4a0c37861e77

(Also add a note to configure.ac as a hint until
someone comes up with a way to sync man/mono.1's
version automatically.)
2016-05-31 16:51:23 +08:00
Marek Safar 86b5cde6c0 [System] Keep broken api in mobile profiles only 2016-05-31 10:07:11 +02:00
Marek Safar 24230862fe [WindowsBase] Fixes test assert expectation logic 2016-05-31 10:07:11 +02:00
Marek Safar 90979903d7 [System] Remove empty test 2016-05-31 10:07:11 +02:00
Marek Safar 599adb0774 Merge pull request #3063 from marek-safar/rs-Net
[System] WebRequest from referencesource
2016-05-31 10:00:21 +02:00
Marek Safar a2147aa78a [System] WebProxy from referencesource 2016-05-31 09:58:26 +02:00
Alexander Köplinger 9f23956396 [ci] Bump timeout in runtime test step
We were seeing timeouts in the runtime step if two builds happen to be scheduled
at the exact same time on the ARM workers on Jenkins, causing increased load and
longer test times. They aborted the runtime step right before it'd finish.

Bump the timeout a bit to avoid this.
2016-05-31 07:05:51 +02:00
Zoltan Varga 7c884f8f63 [bcl] Comment out a win32 pinvoke on the mobile profile, since ios can't have unresolvable pinvokes. 2016-05-30 23:14:52 -04:00
Alex Rønne Petersen 069cea3712 Bump version to 4.5.2. 2016-05-30 20:14:22 +02:00
Vlad Brezae 4ae209510f Merge pull request #3056 from BrzVlad/fix-multiple-binprot
[sgen] Exclusive write on binary protocol file
2016-05-30 19:06:09 +03:00
Vlad Brezae 9afab40925 Merge pull request #3057 from BrzVlad/fix-major-log3
[sgen] Refactor collection logging
2016-05-30 19:04:28 +03:00
Alexander Köplinger 72ef3fb1f6 Merge pull request #3071 from adamburgess/fix-ci-links
Update README with new CI builds/badges
2016-05-30 12:36:55 +02:00
Zoltan Varga d743c659c5 [jit] Emit code to throw method access exceptions instead of throwing them from the JIT, so the stack trace is correct. Fixes #41280. (#3072) 2016-05-30 03:40:56 -04:00
Zoltan Varga ab989b84c7 Revert "[jit] Emit code to throw method access exceptions instead of throwing them from the JIT, so the stack trace is correct. Fixes #41280."
This reverts commit 04171d2c26.
Revert this as it causes test failures.
2016-05-29 22:25:53 -04:00
Zoltan Varga 23e73fd7b7 Revert "[jit] Fix 04171d2c26 so it actually works."
This reverts commit 6683c128e4.
Revert this as it causes test failures.
2016-05-29 22:25:53 -04:00
Alexander Köplinger 340f106a35 [System.Transactions] Fix the build broken by https://github.com/mono/mono/pull/3061 2016-05-30 02:11:33 +02:00
Marek Safar c6d3cc5fa7 Merge pull request #3061 from Thorium/master
#23050 TransactionScopeAsyncFlowOption
2016-05-29 08:22:45 +02:00
Zoltan Varga 6683c128e4 [jit] Fix 04171d2c26 so it actually works. 2016-05-29 00:24:08 -04:00
Zoltan Varga 04171d2c26 [jit] Emit code to throw method access exceptions instead of throwing them from the JIT, so the stack trace is correct. Fixes #41280. 2016-05-29 00:21:58 -04:00
Adam Burgess 0160beb486 Update README with new CI builds/badges
Adds the debian arm64 build and also changes the amd64/i386 builds to be ubuntu-specific
2016-05-28 20:03:20 +10:00
Zoltan Varga 53777008dd [gsharedvt] Fix the mapping of reference generic instances in gsharedvt wrappers, they need to be the same as references. 2016-05-28 01:52:05 -04:00
Bernhard Urban 39bcba8568 Merge pull request #3002 from lewurm/typespec-caching
[aot] use hashtable for caching typespec of classes
2016-05-27 16:50:06 -07:00
Vlad Brezae a3311fab4c [sgen] Exclusive write on binary protocol file
If we have binary protocol enabled and the debugged executable will spawn a new mono instance, both of the processes will write to the same debug file, because they share the environment variable, producing invalid results. Add a pid sufix if output file exists in order to separately obtain binary protocol outputs from all mono instances.
2016-05-28 00:24:55 +03:00
Aleksey Kliger 6af169ff25 [s390x] Fix the build2 2016-05-27 16:19:29 -04:00
Aleksey Kliger 848c482cc6 [s390x] Fix the build
Broken by b884d17
2016-05-27 16:16:21 -04:00
Miguel de Icaza 85d89274bb [genproj] Update from Ankit's project 2016-05-27 16:13:27 -04:00
Aleksey Kliger c18f296c9b [runtime] Avoid mono_error_raise_exception in icalls and debugging utilities 2016-05-27 15:54:47 -04:00
Aleksey Kliger eb4fc33b66 [perfcounters] Convert instance name to C string in the icall entrypoint.
Convert MonoString to UTF8 early to simplify exception handling.
2016-05-27 15:54:46 -04:00
Aleksey Kliger 3ac653123e [reflection] Don't raise in {Module,Assembly}Builder icalls 2016-05-27 15:15:59 -04:00
Alexander Köplinger ee5a06c1a0 Merge pull request #3037 from mono/system_io_compression_datetime
[System.IO.Compression/.Filesystem] Fixed handling of date/time for Zip entries
2016-05-27 20:20:18 +02:00
Vlad Brezae 9dd9ab1c9d [sgen] Don't register pinned objects if pin stats are disabled
On some collections of fsharp, which had many pinned objects, this took up to 10 ms.
2016-05-27 21:10:58 +03:00
Vlad Brezae ead0e31c9c [sgen] Sweep concurrently with nursery collections
When we scan a block we need to have it checked for sweeping. Instead of waiting for all the blocks to be checked for sweeping, we traverse all the blocks (even though they might not have live objects), and do the sweeping check only for blocks that have dirty cards associated with them, without waiting for sweeping to end.
2016-05-27 21:10:58 +03:00
Vlad Brezae abd564253a [sgen] Don't wait for sweep finish when allocating major object
Allocating a major block needs addition to the allocated_blocks array, operation that needs sweep to be finished because sweep moves elements and changes the size when compacting the array. Do this operation in the sweep start instead, when we are not racing.
2016-05-27 21:10:58 +03:00
Vlad Brezae 03ec48b6b1 [sgen] Add missing binary protocol entries for block state set 2016-05-27 21:10:58 +03:00
Miguel de Icaza 87b55c5dc9 [genproj] Run update-solution-files to track master 2016-05-27 13:52:22 -04:00
Miguel de Icaza e4aae0e88f Add another build step 2016-05-27 13:27:32 -04:00
Miguel de Icaza 5515e33fb7 [genproj] Do not use \r on the Unix parts of the build hook, add RabbitMQ hooks 2016-05-27 13:24:16 -04:00
Vlad Brezae 52d58c1c5d [sgen] Refactor collection logging
We had the problem that we were logging at sweep finish which can happen anytime. If we happen to suspend a thread, while doing a GC, in the middle of logging we might deadlock if we wait for sweep to finish (which can be blocked waiting for logging).

When logging multiple collections in the same stw pause, we would not log the real results for both collections since we would compute the major sizes at the very end.

We logged collections in sgen_perform_collection, outside the function calls for specific collections, which makes it cumbersome to add additional log entries.

This refactoring solves these issues by having GC code log info at any time. This log entry is enqueued in a list of pending entries. We flush the list of logs, as before, at the end of the stw, when the world is restarted.
2016-05-27 20:17:43 +03:00
Aleksey Kliger 973dbcaa88 [file-mmap-posix] Don't use mono_error_raise_exception 2016-05-27 12:39:37 -04:00
Alexander Köplinger 0db9b0a3b9 Merge pull request #3060 from directhex/pr-in-version.h
[jenkins] Include PR number in version.h if PR builder env is set
2016-05-27 17:47:54 +02:00
Aleksey Kliger fea81c3ad9 [runtime] Don't raise in mono_assembly_apply_binding 2016-05-27 11:44:53 -04:00
Aleksey Kliger (λgeek) 29ddc7ee3c Merge pull request #3050 from lambdageek/dev/monoerror-to_utf8
[runtime] Mark mono_string_to_utf8 external only.
2016-05-27 10:54:45 -04:00
Alexander Köplinger 388486011e Merge pull request #3058 from rolfbjarne/git-instead-of-ssh
[offsets-tool] Use git protocol instead of ssh to allow anonymous access.
2016-05-27 16:16:09 +02:00
Alexander Köplinger 57e41fd88f Merge pull request #3062 from madewokherd/win32threadscompile
[win32_threads] Mark an inline function as static.
2016-05-27 16:06:57 +02:00
Marek Safar a9a6592513 [corlib] Clean up MonoType declaration 2016-05-27 16:00:05 +02:00
Marek Safar f2b187e972 [System] WebRequest from referencesource 2016-05-27 14:43:17 +02:00
Joao Matos b977ec8ef9 [System.IO.Compression.FileSystem] Fixed date time when creating Zip entries from filesystem files. 2016-05-27 13:03:57 +01:00
Joao Matos 2261009c64 [System.IO.Compression] Added test for Zip entry timestamp modification. 2016-05-27 13:03:02 +01:00
Tuomas Hietanen 1516f24d06 Made changes suggested by marek. 2016-05-27 10:40:09 +01:00
Jo Shields 186288686d [jenkins] Include PR number in version.h if PR builder env is set
A while ago, we switched our PR builders from using the Github-provided PR branch head (i.e. `pull/merge/XXXX`) to the exact sha1 of the latest commit on the PR (i.e. `abcdefabc`). This change was needed for the performance team, otherwise the changes they wanted to test would be rebased against a new master several times per day, breaking their ability to meaningfully track the changes in a PR.

As a side effect of this, `version.h` went from setting the version from `XXXX/abcdefabc` to `explicit/abcdefabc`, and the Jenkins PR packages use the branch name `explicit` instead of the actual PR number `XXXX`, which is pretty bad from a UX perspective.

This change checks for the `ghprbPullId` environment variable and uses it instead of the actual branch name or `explicit` - it is always set on PR builds.
2016-05-27 09:36:11 +01:00
lateralusX 197b70df90 Added support for GSHAREDVT and DYNCALL on Windows x64 for full AOT builds.
Support for GSHAREDVT added for Windows x64. Changes needed
(ones gsharedvt concept was understood, crashes debugged and adjustments located)
where quite small. Primarily around shadow stack used by windows + incorrect handling
of none volatile registers on windows when going over the gsharedvt trampolines.
All GSHAREDVT tests, gshared.exe and aot.tests.exe pass in full AOT builds with above adjustments.

Support for DYNCALL added/enabled for Windows x64. Current AMD64 support was working
for basic scenarios but not enabled on Windows. Identified a problem on AMD64
when structs are passed as input parameters or returned by methods for DYNCALL scenarios
in full AOT:ed builds. This scenario doesn't seem to work for any AMD64 platform for
full AOT and the tests in aot-test.exe handling these scenarios are not run on AMD64.

Adjusted categories on test in aot-tests.exe to reflect what’s really needed by the tests
to run correctly. Also added a new category to some DYNCALL tests that uses struct support
currently not implemented on AMD64, !FULLAOT-AMD64, so at least some of the DYNCALL tests
can be run on AMD64 platforms in full AOT:ed builds.
2016-05-27 10:22:32 +02:00
Zoltan Varga 2eab1a97dd Remove an unused icall. 2016-05-26 22:50:30 -04:00
monojenkins 82f74ede88 Merge pull request #3026 from lewurm/is-call-macro
[mini] small improvements around `MONO_IS_CALL` macro and `local-prop`

showed up in vtunes when running 
```
./mono/mini/mono-sgen --stats -O=all --aot=threads=1,asmonly ~/work/benchmarker/tests/fsharp/lib/bootstrap/4.0/FSharp.Compiler.dll
```

also, I think when `OP_DYN_CALL` was introduced, it wasn't added to the `MONO_IS_CALL` macro. @vargaz, what do you think?
2016-05-27 02:25:07 +01:00
Zoltan Varga ee6c7cf065 [sdb] Avoid calling mono_thread_current () in the profiler shutdown callback, sends a 0 thread id instead, the managed side ignores it. 2016-05-26 18:55:57 -04:00
Bernhard Urban bb806ba1d6 [mini] avoid checking condition twice in local-prop 2016-05-26 15:41:29 -07:00
Bernhard Urban e197d13f81 [mini] simplify MONO_IS_CALL macro 2016-05-26 15:41:29 -07:00
Zoltan Varga d88424370f Merge System/MonoType.cs into ReferenceSources/RuntimeType.cs, use th… (#3045)
* Merge System/MonoType.cs into ReferenceSources/RuntimeType.cs, use the latter in the runtime code.

* [sdb] Fix a test which referenced System.MonoType.
2016-05-26 18:33:41 -04:00
Vincent Povirk 0830b25dc3 [win32_threads] Mark an inline function as static.
If the C compiler decides not to inline the function, and it's not declared
static, it'll look for an extern version, and linking will fail.
2016-05-26 16:50:42 -05:00
Aleksey Kliger b884d173c7 [runtime] Mark mono_string_to_utf8 external only.
Runtime should use mono_string_to_utf8_checked.
2016-05-26 15:13:37 -04:00
Aleksey Kliger (λgeek) 5cb30c7c72 Merge pull request #3055 from lambdageek/dev/monoerror-cleanup-cleanup
[runtime] Disallow unintended reuse of MonoError after mono_error_cleanup
2016-05-26 11:26:33 -04:00
Tuomas Hietanen 820be6c036 Merge branch 'master' of https://github.com/mono/mono 2016-05-26 15:07:30 +01:00
Tuomas Hietanen c9c563fa5b #23050 First attempt to create TransactionScopeAsyncFlowOption on Mono.
This is a feature that is missing. However I don't have Mono,
so has to be compiled and tested.
2016-05-26 15:05:29 +01:00
Ludovic Henry 7ebae4c7f5 Merge pull request #3028 from lateralusX/jlorenss/threadpool_warning
Incorrect warning message on thread pool startup in full AOT:ed Windows build.
2016-05-26 15:26:51 +02:00
Marek Safar 478db45ebd Merge pull request #3047 from marek-safar/rs-corlib
[corlib] More System.Runtime.InteropServices from referencesource
2016-05-26 11:15:27 +02:00
Rolf Bjarne Kvinge b41f0700a2 [offsets-tool] Use git protocol instead of ssh to allow anonymous access. 2016-05-26 09:54:43 +02:00
Zoltan Varga b657c7b0e6 Aot runtime noraise3 (#3054)
* [aot] Make mono_aot_get_method () external only, use mono_aot_get_method_checked () instead.

* [aot] Avoid raising exceptions in the AOT runtime.
2016-05-25 23:58:36 -04:00
Aleksey Kliger ab24b51671 [reflection] Reinitialize MonoError after mono_error_convert_to_exception 2016-05-25 19:27:39 -04:00
Aleksey Kliger 169985dcd5 [mini] Use an inner MonoError in instance testing in first pass EH 2016-05-25 19:23:16 -04:00
Aleksey Kliger d64ef7799b [runtime] Disallow unintentional reuse of MonoError after mono_error_cleanup 2016-05-25 19:11:45 -04:00
Aleksey Kliger fc950dc5bc [reflection] Cleanup uses of mono_error_cleanup
MonoError must be explicitly reinitialized if it is used again after
mono_error_cleanup.  But it is better to introduce an explicit inner
MonoError when possible.
2016-05-25 18:34:43 -04:00
Mark Probst 4afc91e8b9 [sgen] Remove a stupid #define 2016-05-25 15:13:05 -07:00
Mark Probst 1800992952 [sgen] Cheap pinning statistics by default. 2016-05-25 15:13:01 -07:00
Mark Probst 0a7194b7c3 [sgen] Add an assertion. 2016-05-25 15:12:37 -07:00
Mark Probst 76bdd84ce9 [sgen] Do pin stats for small major objects, too. 2016-05-25 15:12:32 -07:00
Mark Probst 855bc894db [sgen] Don't pin empty slots in the major heap. 2016-05-25 15:12:10 -07:00
Zoltan Varga 50a7096539 [llvmonly] Avoid calling mono_error_raise_exception () to throw exceptions during method initialization, call mono_llvm_throw_exception () directly. 2016-05-25 16:59:57 -04:00
Alexander Köplinger 66ab64f2a0 Merge pull request #3051 from mono/revert-3043-aot-runtime-noraise
Revert "[aot] Avoid raising exceptions in the AOT runtime."
2016-05-25 21:50:30 +02:00
Alexander Köplinger 778bbe819c Revert "[aot] Avoid raising exceptions in the AOT runtime." 2016-05-25 21:48:39 +02:00
Sebastien Pouliot 8c14f0d410 Merge pull request #2996 from UCIS/patch-7
Generate RSA keys using public exponent 65537 (was 17)
2016-05-25 15:11:22 -04:00
Alexander Köplinger e765e70945 Merge pull request #3036 from tritao/windowsbase_zip_datetime
[WindowsBase] Fixed System.IO.Packaging creating Zip archive with wrong date time entries
2016-05-25 19:28:55 +02:00
Bernhard Urban 532e618a14 Merge pull request #3016 from lewurm/small-arm-cleanup
[mini-arm] remove useless case for iphone_abi
2016-05-25 09:56:39 -07:00
Bernhard Urban 34687fb5a6 [aot] use hashtable for caching typespec of classes
I had a look in vtunes for

```
$ mono/mini/mono-sgen --stats -O=all --aot=threads=1,asmonly ~/work/benchmarker/tests/fsharp/lib/bootstrap/4.0/FSharp.Compiler.dll
```

and that method showed up as hot.

With this change I get an improvement from ~27.4s down to ~24.3s on my
machine.
2016-05-25 09:48:55 -07:00
Zoltan Varga 39d436290e [aot] Avoid raising exceptions in the AOT runtime. (#3043) 2016-05-25 12:35:39 -04:00
Marek Safar aae26db0c2 [WindowsBase] Fix for the new .rels file when it's shorter than the old. A fix for #41203 2016-05-25 17:03:50 +02:00
Aleksey Kliger (λgeek) 07bcf1a3c2 Merge pull request #3038 from lambdageek/dev/monoerror-threads
[threadpool-ms] Assert if queuing work items fails in the IO selector
2016-05-25 10:36:20 -04:00
Aleksey Kliger (λgeek) effdfb78ac Merge pull request #3042 from lambdageek/dev/monoerror-upgrade_remote_class
[remoting] Pass MonoError to mono_upgrade_remote_class
2016-05-25 10:12:25 -04:00
Aleksey Kliger (λgeek) f6adb102d4 Merge pull request #3044 from lambdageek/dev/monoerror-llvm
[llvm] Convert MonoError to LLVM ctx failure in process_call
2016-05-25 09:56:53 -04:00
Marek Safar 58f4315bd8 Merge pull request #3046 from redbrain/cfnetworking-null-reference
ContentStream can be null
2016-05-25 15:24:41 +02:00
Philip Herron 6425014c8f ContentStream can be null if no bytes were available and is closed will cause null-exception 2016-05-25 14:18:59 +01:00
Marek Safar 08a3251b91 [corlib] More System.Runtime.InteropServices from referencesource 2016-05-25 14:59:06 +02:00
Marek Safar d3f789f3c9 [WindowsBase] Deal with deleted package parts. A patch from #41203 2016-05-25 11:02:50 +02:00
Miguel de Icaza 2f21472994 [genproj] Handle resources properly, add helper scripts to bootstrap 2016-05-24 17:44:11 -04:00
Zoltan Varga 0ce5f9c721 [amd64] Implement the general rgctx fetch trampoline. 2016-05-24 16:37:58 -04:00
Aleksey Kliger a93a43d0a7 [llvm] Convert MonoError to LLVM ctx failure in process_call 2016-05-24 16:33:21 -04:00
Aleksey Kliger 920c7ae031 [llvmonly] Assert gsharedvt wrapper compile always succeeds. 2016-05-24 16:33:21 -04:00
Zoltan Varga 157360864a [jit] Optimize ldnull+unbox.any pairs, mcs generates it for code like f = null where f is a field of a generic type with an open type. 2016-05-24 16:08:11 -04:00
Zoltan Varga 2fb2f261e2 [amd64] Add back an assert removed by the previous change. 2016-05-24 15:35:25 -04:00
Zoltan Varga b80c9c5438 [amd64] Handle genericinst return types in gsharedvt. 2016-05-24 15:30:35 -04:00
Aleksey Kliger 7d5a44d39c [remoting] Pass MonoError to mono_upgrade_remote_class 2016-05-24 13:41:02 -04:00
Aleksey Kliger 8468ba85ce [remoting] Pass MonoError to mono_remote_class_vtable 2016-05-24 13:41:02 -04:00
Aleksey Kliger 412a024351 [remoting] Pass MonoError to mono_class_proxy_vtable 2016-05-24 13:41:02 -04:00
Aleksey Kliger e3c54423eb [remoting] MonoError-ize arch_create_remoting_trampoline 2016-05-24 13:41:02 -04:00
Marek Safar 3f7e999303 [System.Net.Http] Disable default global proxy when only UseProxy is set. Fixes #41224 2016-05-24 19:12:30 +02:00
Zoltan Varga 7261f57e48 [arm64] Enable system AOT. 2016-05-24 11:47:42 -04:00
Zoltan Varga 5588e15905 Fix warnings. 2016-05-24 11:43:37 -04:00
Aleksey Kliger (λgeek) 875d3f6c5d Merge pull request #3024 from lambdageek/dev/monoerror-endinvoke
[threadpool-ms] MonoError-ize mono_threadpool_ms_end_invoke
2016-05-24 11:11:48 -04:00
Aleksey Kliger (λgeek) fe8558dcfc Merge pull request #3029 from lambdageek/dev/simplify-monoerror-threads
[runtime] Simplify MonoError handling in finalizer creation and in thread objects
2016-05-24 11:08:01 -04:00
Aleksey Kliger (λgeek) 939da2c3ac Merge pull request #3041 from lambdageek/dev/monoerror-mono_arch_patch_code
[ia64/mips/ppc/s390x/sparc] Add MonoError arg to mono_arch_patch_code
2016-05-24 10:29:26 -04:00
Aleksey Kliger f234736118 [ia64/mips/ppc/s390x/sparc] Add MonoError arg to mono_arch_patch_code 2016-05-23 19:17:42 -04:00
Andi McClure 37da53ace7 Debugger stepping does not understand recursion (bug 38025)
Testing with the debugger showed multiple failures around recursive
functions:

1. Step-out breakpoints can trigger on inner frames.
Solution: Extend existing inner-frame test from step-over to step out
also.

2. "Same source line, continuing" test triggers even on wrong frame
   (affects both step over and step out)
Solution: Check frame as part of this test

3. When step breakpoints pick next sequence points, they can register
   multiple breakpoints at the same place if a recursive call happens to
   exit there. (Possibly harmless but may have resulted in duplicate
   debugger events being generated in one test.)
Solution: Check for duplicates in step-request breakpoint list before
adding new breakpoints

4. Mono.Debugging.Soft in the debugger-libs repo sometimes resumes
   after breakpoints if it decides Mono.Debugger.Soft has not stepped
   far enough, but the check to trigger this was not recursion-aware.
Solution: This one is not addressed in this commit, but a fix was
checked in to debugger-libs. Any code using this commit therefore
needs to be run in conjunction with debugger-libs dfbf6d8b13.

Tests were also added for issues 1-3 above.
2016-05-23 19:04:06 -04:00
Aleksey Kliger (λgeek) 68ee996c8d Merge pull request #3032 from lambdageek/dev/monoerror-gc
[runtime] Don't raise MonoErrors in mono_gc_run-finalize
2016-05-23 18:37:10 -04:00
Rodrigo Kumpera dd0e3f8d96 [runtime] Cleanup how we map WAIT_FAILED to what managed expects. 2016-05-23 15:12:36 -07:00
Rodrigo Kumpera a9294c2e57 [coop] Change self_abort_internal to take a MonoError to report that an exception must be raised. 2016-05-23 15:11:25 -07:00
Rodrigo Kumpera 3330e5bc89 [runtime] Change mono_thread_internal_stop to only stop other threads. Mask mono_thread_stop as MONO_RT_EXTERNAL_ONLY.
This change makes it not need to throw exceptions.

In the runtime, use mono_thread_internal_stop instead of mono_thread_stop.
mono_thread_internal_stop only stops other threads, which is what runtime usage calls for.
mono_thread_stop will stop the current thread by raising and exception.
2016-05-23 15:11:25 -07:00
Rodrigo Kumpera 9ca8d98fd2 [runtime] Introduce mono_thread_internal_abort to be used instead of ves_icall_System_Threading_Thread_Abort. 2016-05-23 15:11:24 -07:00
Rodrigo Kumpera 20525c99e6 [runtime] Change mono_thread_current_check_pending_interrupt to use mono_set_pending_exception.
Callers now check its return and set a pending exception.
2016-05-23 15:11:23 -07:00
Rodrigo Kumpera ceba6204a1 [runtime] Simplify mono_wait_uninterrupted, remove two arguments that are needed.
The first argument is whether it's a single or multiple wait. We can infer that from the number of handles.
The second argument is alertable. All waits are alertable, so I baked the constant directly.
2016-05-23 15:11:23 -07:00
Rodrigo Kumpera 79c6ba6976 [coop] Use MonoError in mono_wait_uninterrupted.
This removes an usage of mono_raise_exception by a set_pending
2016-05-23 15:11:22 -07:00
Aleksey Kliger 9023662ce9 [threapool-ms] Assert if queuing work items fails 2016-05-23 17:46:29 -04:00
Aleksey Kliger 1472f2365a [runtime] Don't raise in mono_threads_get_thread_dump 2016-05-23 17:42:36 -04:00
Miguel de Icaza f06f1e62b9 [genproj] Properly include EmbeddedResources for .resx->resources 2016-05-23 17:03:03 -04:00
Zoltan Varga b00622cf66 [runtime] Remove some older glib workarounds. 2016-05-23 15:48:24 -04:00
Zoltan Varga fa9a113f7f [eglib] Use the PRi64 defines from inttypes.h to define G_GINT64_FORMAT etc. Get rid of support for older MSVC versions. 2016-05-23 15:48:08 -04:00
Joao Matos bc1967e73b [System.IO.Compression] Fixed date time handling of Zip entries. 2016-05-23 20:19:22 +01:00
Zoltan Varga 8d403e73a7 [runtime] Remove some dead code. 2016-05-23 14:46:09 -04:00
Aleksey Kliger f2868b89b3 [runtime] Push null check to callers of mono_object_register_finalizer
Simplify error propagation since most callers register a finalizer after
doing their own null check.
2016-05-23 13:48:52 -04:00
Aleksey Kliger 30a1a8a477 [runtime] Assert in create_thread_object and create_internal_thread
They can only ever fail if allocation fails, which we can't recover
from, so let's just assert that we succeed.

This in turn simplifies the error handling in a lot of other thread routines.
2016-05-23 13:48:52 -04:00
Aleksey Kliger 02446eebea [runtime] (remoting.c) Get rid of mono_error_raise_exception calls 2016-05-23 13:40:00 -04:00
Aleksey Kliger 33477fa35b [runtime] Don't raise MonoErrors in mono_gc_run-finalize
Ship them off to unhandled exception handling instead.
2016-05-23 13:33:36 -04:00
Aleksey Kliger e6deea5e3b [threadpool-ms] MonoError-ize mono_threadpool_ms_end_invoke 2016-05-23 13:26:16 -04:00
Alexander Köplinger 6890eab27f Redist the referencesource folder
Since referencesource is no longer a submodule under external/ after https://github.com/mono/mono/pull/2962
it didn't get included in the tarball anymore.

We need to add it again to fix the tarball build.
2016-05-23 19:16:05 +02:00
Zoltan Varga d02fa64e5f [arm64] Add missing mini-arm64-gsharedvt.h file to arm64_sources. 2016-05-23 12:50:25 -04:00
Alexander Köplinger f38d1b2adb [msvc] Update .def files 2016-05-23 16:44:40 +02:00
Alexander Köplinger b5e37e7a95 Merge pull request #3033 from akoeplinger/fix-xbuild
Various xbuild 14.0 fixes
2016-05-23 15:52:17 +02:00
Rodrigo Kumpera eaca1ba8ed Merge pull request #3035 from mono/revert-3025-mono_raise_exception_in_threads
Revert "[coop] Remove mono_raise_exception from threads.c"
2016-05-22 16:10:13 -07:00
Rodrigo Kumpera 5a32c69ec2 Revert "[coop] Remove mono_raise_exception from threads.c" 2016-05-22 16:09:43 -07:00
Ludovic Henry d0ffec1ae1 Merge pull request #3018 from ludovic-henry/coop-marshal-attach
[coop] Generate native-to-managed thread attaching in marshal + Reset mono_jit_thread_attach signature
2016-05-20 19:52:01 -04:00
Rodrigo Kumpera 81bd8db9cf Merge pull request #3025 from kumpera/mono_raise_exception_in_threads
[coop] Remove mono_raise_exception from threads.c
2016-05-20 16:22:43 -07:00
Rodrigo Kumpera 326b021383 [runtime] Cleanup how we map WAIT_FAILED to what managed expects. 2016-05-20 16:20:28 -07:00
Rodrigo Kumpera 9657f07a9b Merge pull request #3030 from kumpera/fix_locale
[eglib] Ignore nl_langinfo as it doesn't return the actual system default.
2016-05-20 14:44:05 -07:00
Alexander Köplinger 30dd64033c [xbuild] Add AssignLinkMetadata to xbuild 14
This is essentially the same as https://github.com/mono/mono/commit/639bf661715fc190b595d05193c335f70b3313eb but for the xbuild 14 profile.
2016-05-20 23:37:22 +02:00
Alexander Köplinger 4103bd9aae [xbuild] Make sure MSBuildFrameworkToolsPath is set for xbuild 14 2016-05-20 23:37:21 +02:00
Alexander Köplinger d44824b7f8 [xbuild] Fix DependsOnSystemRuntime returning false on xbuild 14
In https://github.com/mono/mono/commit/4164d9fbe19a1e6acb3a5ea122891020ff2868d7 the 14.0 target was updated to include
the DependsOnSystemRuntime property. However, it wasn't actually implemented in the code behind. This resulted in the
property not being set/true even if we depend on assemblies that reference System.Runtime, which in turn leads us to not
adding the Facades in ImplicitlyExpandDesignTimeFacades. This then breaks compilation because the System.Runtime lookup fails.

The fix is to actually implement the property.
2016-05-20 23:37:20 +02:00
Rodrigo Kumpera ef1f0fe899 [coop] Change self_abort_internal to take a MonoError to report that an exception must be raised. 2016-05-20 14:00:17 -07:00
Rodrigo Kumpera fc94a140b8 [runtime] Change mono_thread_internal_stop to only stop other threads. Mask mono_thread_stop as MONO_RT_EXTERNAL_ONLY.
This change makes it not need to throw exceptions.

In the runtime, use mono_thread_internal_stop instead of mono_thread_stop.
mono_thread_internal_stop only stops other threads, which is what runtime usage calls for.
mono_thread_stop will stop the current thread by raising and exception.
2016-05-20 13:57:53 -07:00
Rodrigo Kumpera fbedfe313c [runtime] Introduce mono_thread_internal_abort to be used instead of ves_icall_System_Threading_Thread_Abort. 2016-05-20 13:56:04 -07:00
Rodrigo Kumpera ccfd0ac779 [runtime] Change mono_thread_current_check_pending_interrupt to use mono_set_pending_exception.
Callers now check its return and set a pending exception.
2016-05-20 13:56:04 -07:00
Rodrigo Kumpera 5d8b146abc [runtime] Simplify mono_wait_uninterrupted, remove two arguments that are needed.
The first argument is whether it's a single or multiple wait. We can infer that from the number of handles.
The second argument is alertable. All waits are alertable, so I baked the constant directly.
2016-05-20 13:55:59 -07:00
Rodrigo Kumpera a884522d6a [coop] Use MonoError in mono_wait_uninterrupted.
This removes an usage of mono_raise_exception by a set_pending
2016-05-20 13:54:27 -07:00
Rodrigo Kumpera 69588659ab [eglib] Ignore nl_langinfo as it doesn't return the actual system default. Fixes #41128.
nl_langinfo doesn't query the right system value, it returns ASCII on OSX, for example.
2016-05-20 12:00:25 -07:00
Aleksey Kliger (λgeek) 8c8ce9f3bd Merge pull request #3023 from lambdageek/dev/monoerror-minisig
[mini] Propagate MonoError in mini_get_signature
2016-05-20 10:06:28 -04:00
lateralusX cfc1228c9b Incorrect warning message on thread pool startup in full AOT:ed Windows build.
When running mono/mini aot-tests.exe on full AOT:ed Windows build the following
warning message is incorrectly written to the console several times:

g_warning ("failed to get 100ns ticks");

This happens since the check triggering this warning is not taking into account
that startup time between first call to mono_ns100_ticks storing the start time
and the launch of the thread pool requesting 100ns ticks and convert it to
elapsed seconds can occur during the first second of the process lifetime.
This is more likely to happen in a full AOT:ed image since nothing needs to
be JIT:ed at startup, making it more likely to exploit the problem reaching this
code within the first second of process lifetime.

The purpose of the check is to validate that mono_ns100_ticks is returning “valid”
data, but currently it checks it after converting it to seconds, meaning that the result
of the division gets truncated to 0 during the first second. The only invalid, deterministic error
from mono_ns100_ticks that could be used to trigger this warning is either 0 or a negative time value,
but currently it just checks for 0 as an error. The fix is to make the check on the return from
mono_ns100_ticks instead of on the result of the division by 10 000 000 as it is today.
2016-05-20 11:27:48 +02:00
Alexander Köplinger 96dca28adb Merge pull request #3027 from akoeplinger/ci-bump-timeout
[ci] Bump timeout for runtime tests
2016-05-20 04:02:04 +02:00
Alexander Köplinger 9ff9d495ca [ci] Bump timeout for runtime tests
On the new Jenkins infrastructure with the new ARM64 bots we're hitting the 2h runtime test
limit right before they'd be finished. Bump the timeout a bit to fix this.
2016-05-20 02:29:25 +02:00
Rodrigo Kumpera 127f4b0cd1 [coop] Use set_pending in ves_icall_System_Threading_Thread_Sleep_internal, it's an icall. 2016-05-19 14:13:45 -07:00
Aleksey Kliger 1c15e9bf78 [mini] Propagate MonoError in mini_get_signature
Also mark mono_metadata_parse_signature external only, runtime should
use mono_metadata_parse_signature_checked
2016-05-19 16:53:17 -04:00
Aleksey Kliger 75b33af0f3 [runtime] (threads.c, marshal.c) Set pending exception in a few icalls 2016-05-19 16:53:17 -04:00
Miguel de Icaza e90c2a56eb Add missing project file 2016-05-19 14:07:09 -04:00
Miguel de Icaza 5100a64596 [msbuild projects] Use newlines without a carriage return for Unix targets to appease MS msbuild 2016-05-19 12:50:55 -04:00
Zoltan Varga fbe5d3d9b9 [llvm] Avoid emitting got slots of type MONO_PATCH_INFO_ICALL_ADDR when using direct pinvokes, since the patch is not needed, and it cannot be resolved on platforms without a working dlsym(). 2016-05-19 12:18:49 -04:00
Ludovic Henry 4294e09fea [coop] Reset mono_jit_thread_attach signature
XM depends on mono_jit_thread_attach signature, even if it's not a public API. So to avoid breaking it, we need to reset it to its previous signature.
2016-05-19 12:18:31 -04:00
Miguel de Icaza 869ca554f0 [genproj] Fix the Makefile THISDIR location, so MSBuild can work with nunit.core 2016-05-19 11:55:32 -04:00
Miguel de Icaza db86e3a3e4 Do not sign the assembly 2016-05-19 11:49:58 -04:00
Ludovic Henry cf61ae311e [coop] Generate native-to-managed thread attaching in marshal 2016-05-19 11:31:11 -04:00
Miguel de Icaza 596d1d1621 [genproj] Now we can build all executables with msbuild as well 2016-05-19 10:09:23 -04:00
Alexander Köplinger f89fef62f2 Merge pull request #3017 from akoeplinger/fix-drawing-arm64
[System.Drawing] Disable failing PngCodec 2bpp tests on ARM64
2016-05-19 15:53:57 +02:00
Alexander Köplinger 56ad07531d Merge pull request #2998 from lateralusX/jlorenss/win-x64-full-aot-support
Windows x64 full AOT support for mono/mini regression tests.
2016-05-19 13:36:19 +02:00
Marek Safar 85c642b521 Merge pull request #3020 from akoeplinger/fix-ttl
[System] Raise ArgumentOutOfRangeException for values > 255 in Socket.Ttl setter
2016-05-19 10:42:24 +02:00
Miguel de Icaza af5812c8f1 Update .gitignore, remove stale file 2016-05-18 23:49:26 -04:00
Miguel de Icaza a0ac8b2024 [System.Windows.Forms] Fix incorrect compare of IntPtr to null 2016-05-18 23:42:10 -04:00
Miguel de Icaza 1d95af860b [genproj] Fix THISDIR location in a few projects, so genproj can generate MSBuild files 2016-05-18 23:35:45 -04:00
Miguel de Icaza 689ca75d63 [System.Web] Remove duplicate file listings which break msbuild and update csprojs 2016-05-18 22:51:25 -04:00
Alexander Köplinger de13dc2532 [System] Raise ArgumentOutOfRangeException for values > 255 in Socket.Ttl setter
This is consistent with the .NET implementation: https://github.com/mono/mono/blob/8054793e5bc158015154fb8cdcdd56777a0c8351/mcs/class/referencesource/System/net/System/Net/Sockets/Socket.cs#L734-L737 (sadly, MSDN says SocketException should be thrown in this case...).

It fixes the SocketTest.TtlChangeoverflow test that started failing after https://github.com/mono/mono/pull/2250.
The reason is we refactored the SetSocketOption () overload the Ttl setter is using so that it now
checks for `error == (int) SocketError.InvalidArgument` instead of just falling through to raising
a SocketException with the error code.
2016-05-19 04:27:12 +02:00
Alexander Köplinger 60497b4bfb [System.Drawing] Disable failing PngCodec 2bpp tests on ARM64
They fail on the new Jenkins ARM64 bots, disable them until we figure out the cause.
It looks like a libgdiplus issue to me which makes deploying a fixed version a bit more difficult.

Filed https://bugzilla.xamarin.com/show_bug.cgi?id=41171 to track.
2016-05-19 02:08:21 +02:00
Rodrigo Kumpera 8054793e5b Merge pull request #2992 from lambdageek/dev/monoerror-other-invokes
[runtime] MonoError mono_runtime_invoke_{array,delegate}
2016-05-18 16:44:52 -07:00
Rodrigo Kumpera 28c62efb8d Merge pull request #2989 from lambdageek/dev/monoerror-message
[runtime] MonoError for mono_message_init
2016-05-18 16:43:05 -07:00
Rodrigo Kumpera 58e23811aa Merge pull request #2977 from BrzVlad/fix-major-log2
[sgen] Improve logging
2016-05-18 16:41:50 -07:00
Miguel de Icaza de3aa63805 [genproj] Sync with latest set of changes to Makefiles 2016-05-18 18:08:38 -04:00
Miguel de Icaza 33ed1e451f [genproj] Use an explicit IntermediateOutputPath to prevent rebuilds on cyclic assemblies 2016-05-18 17:59:25 -04:00
Bernhard Urban 23a9263945 [mini-arm] remove useless case for iphone_abi 2016-05-18 14:52:05 -07:00
Vlad Brezae fd3e254da2 [sgen] Fix warnings at printing 64bit ints 2016-05-18 23:53:13 +03:00
Vlad Brezae cd14c006d1 [sgen] Refactor sgen_perform_collection
This enables logging for major concurrent collections and for nursery collections while a concurrent collection is running.
2016-05-18 23:53:13 +03:00
Vlad Brezae 1e2e111c38 [sgen] Log also the real size used by the major objects
Due to performance concerns, we don't account for the space wasted in blocks, since it would require dereferencing all vtables. We also don't account for allocation that might happen during sweep.
2016-05-18 23:53:13 +03:00
Vlad Brezae f9951e0d9a [sgen] Log also the total los memory usage 2016-05-18 23:53:12 +03:00
Vlad Brezae f639e5d1c0 [sgen] Don't log previous collection memory size
This information can be found in the previous log entries.
2016-05-18 23:53:12 +03:00
Vlad Brezae 1a9542c969 [sgen] Precisely log the size of the promoted objects during minors 2016-05-18 23:53:10 +03:00
Rodrigo Kumpera 0dc17dcc9e Merge pull request #3008 from lateralusX/jlorenss/win-x64-shutdown-crash
[runtime] Fix for random, timing dependent, mono runtime crash during shutdown on Windows.
2016-05-18 13:45:22 -07:00
Marek Safar 9e58da5408 Merge pull request #3012 from marek-safar/rs-Net
[System] WebHeaderCollection from referencesource
2016-05-18 21:58:06 +02:00
Aleksey Kliger d9fa4d34c9 [runtime] MonoError-ize mono_message_invoke 2016-05-18 15:41:13 -04:00
Aleksey Kliger 3c9ab3e991 [runtime] MonoError-ize mono_runtime_invoke_array
As with mono_runtime_invoke, we split up into three functions:
1. mono_runtime_invoke_array is external only.  Runtime should use
   one of the other two.
2. mono_runtime_invoke_array_checked threads exceptions and failures through
  MonoError in coop mode.  In non-coop managed exceptions unwind the
  stack as before.
3. mono_runtime_try_invoke_array sends exceptions from method invocation
through a MonoException* outarg, and other errors through MonoError.
2016-05-18 15:41:13 -04:00
Aleksey Kliger 413ec4e0ea [runtime] Refactor mono_runtime_invoke_array
Pull a helper function invoke_array_extract_argument out to simplify
error handling.
2016-05-18 15:40:26 -04:00
Aleksey Kliger 3e0081e924 [runtime] MonoError-ize mono_runtime_delegate_invoke
Mark it external only.  Runtime can use
mono_runtime_delegate_invoke_checked or mono_runtime_delegate_try_invoke.
2016-05-18 15:40:26 -04:00
Aleksey Kliger c22a9b2f75 [runtime] Don't raise while calling unhandled exception delegate. 2016-05-18 15:40:26 -04:00
Zoltan Varga 81f9ed3195 [runtime] Remove an unused variable. 2016-05-18 15:40:20 -04:00
Ludovic Henry 3ca530a8bd Merge pull request #2994 from ludovic-henry/remove-nacl
[runtime] Remove support for NaCl
2016-05-18 15:36:45 -04:00
Aleksey Kliger 53ae4aa5a5 [runtime] MonoError-ize mono_message_init 2016-05-18 15:35:09 -04:00
Aleksey Kliger 9acccc0529 [runtime] MonoError-ize mono_marshal_xdomain_copy_value 2016-05-18 15:35:09 -04:00
Aleksey Kliger 85f5330e8f [runtime] MonoError-ize mono_method_call_message_new 2016-05-18 15:35:09 -04:00
Aleksey Kliger 8e226498a1 [runtime] MonoError-ize mono_delegate_ctor 2016-05-18 15:35:09 -04:00
Aleksey Kliger ac0160c043 [runtime] MonoError-ize mono_async_result_new 2016-05-18 15:35:09 -04:00
Aleksey Kliger b0d64d0121 [runtime] MonoError-ize mono_ldstr
Mark it external only.  Runtime should use mono_ldstr_checked.
2016-05-18 15:35:09 -04:00
Miguel de Icaza 52b0510b10 Remove more deprecated stuff 2016-05-18 15:30:25 -04:00
Miguel de Icaza d12eae59dc Remove dead code, update solution files 2016-05-18 15:26:07 -04:00
Miguel de Icaza 6cf2c991e9 genproj: Improve handling of executables and projects with build dependencies 2016-05-18 15:19:27 -04:00
Aleksey Kliger (λgeek) 3fc2fee18d Merge pull request #2815 from lambdageek/dev/monoerror-mono_compile_method
[runtime] MonoError-ize mono_compile_method
2016-05-18 15:15:16 -04:00
Aleksey Kliger (λgeek) c3d14ecb94 Merge pull request #3014 from lambdageek/dev/coop-enabled
[coop] Make mono_threads_is_coop_enabled a normal function
2016-05-18 13:15:03 -04:00
Alexander Köplinger 5c89ec97cc Merge pull request #3007 from directhex/use-mingw64
[jenkins] Use mingw64 to build, not 32
2016-05-18 17:40:15 +02:00
Aleksey Kliger f99a0f713c [coop] Make mono_threads_is_coop_enabled a normal function
It doesn't need to live in the header.

In particular is_coop_enabled variable used to be in every translation
unit instead of just a single flag.
2016-05-18 11:19:23 -04:00
Alexander Köplinger 4cbd7a6ab6 Merge pull request #3011 from akoeplinger/ci-fixes
[ci] Move setting CFLAGS and MONO_CHECK_MODE into the run-jenkins.sh script
2016-05-18 17:18:38 +02:00
Marek Safar 9c351d5028 Merge pull request #3003 from marek-safar/rs-NetworkInformation
[System] Common NetworkInformation code from referencesource
2016-05-18 16:18:28 +02:00
Miguel de Icaza 5676287097 Graduate the csproj/solution to completed - you can now build with the toplevel net_4_x.sln 2016-05-18 10:15:17 -04:00
Alexander Köplinger 4c466bc318 Merge pull request #3009 from akoeplinger/fix-sockettest-catch
[System] Get rid of useless catch-all clauses in SocketTest
2016-05-18 16:06:11 +02:00
Marek Safar d3b0701f62 [System] Common NetworkInformation code from referencesource 2016-05-18 16:02:38 +02:00
Jo Shields 388a9c96b0 [jenkins] Use VS2015, not 2013 2016-05-18 14:56:44 +01:00
Miguel de Icaza f0a3d89bec Remove [assembly:TargetFramework] as no other assembly uses it, and causes our msbuild to fail 2016-05-18 09:45:18 -04:00
Miguel de Icaza 0c8816daa6 [WIP] Important change: more comprehensive Makefile to support csproj-local on System.Design (#3006)
* Important change: more comprehensive Makefile to support csproj-local on System.Design

* Change the dependency

* update
2016-05-18 09:28:42 -04:00
Marek Safar ba81e38ecc [System] WebHeaderCollection from referencesource 2016-05-18 14:44:07 +02:00
Rolf Bjarne Kvinge e4d33f70d4 [System] Throw PlatformNotSupportedException if NetworkInformation.NetworkChange is used on watchOS. (#3010)
NetworkInformation.NetworkChange requires the SystemConfiguration framework,
which isn't available on watchOS.
2016-05-18 08:21:23 -04:00
Alexander Köplinger 15c311adab [ci] Move setting CFLAGS and MONO_CHECK_MODE into the run-jenkins.sh script
So we can further reduce the state we keep on Jenkins itself.
2016-05-18 14:16:12 +02:00
Alexander Köplinger 3d2ddac37f [System] Get rid of useless catch-all clauses in SocketTest
When one of the tests doesn't fail with the expected exception, we'd get just a useless message
like "TtlChangeoverflow #3" instead of the much more useful exception info + stacktrace that
NUnit catches when an unhandled exception is thrown.
2016-05-18 13:38:48 +02:00
lateralusX be0e803812 Fix for rare mono runtime crash during shutdown sequence on Windows.
During mono shutdown on windows there is, on rare occasions, an exception
in CloseHandle indicating the closure of an invalid handle. This exception
is normally a strong indication of a much more severe underlying problem,
a doubled close on a handle, that could lead to random data corruptions
and very hard to track bugs in random areas of the code. If the system reused
the handle for a different object that silently gets incorrectly closed by above
call, the above bug could manifest itself into some completely different issues,
so getting a consistent repro with the above exception with CloseHandle was a good
point to start tracking down the bug.

The exception throwed in CloseHandle boils down to the fact that threads
in thread pool's that have their finalizer run on shutdown can end up in
a scenario where the thread handle has already been closed elsewhere.

When the threads are finalized in mono_gc_finialize_threadpool_threads,
the handle on the internal thread object, stored in MonoInternalThread,
will be closed by the thread objects finializer in ves_icall_System_Threading_InternalThread_Thread_free_internal.
Under some rare occasions, one of the handles are not valid and will cause
the exception in CloseHandle or even worse, pointing to a complete different
kind of object, potentially closed by the threads finalizer, causing an instable
process with random behavior related to WIN32 objects (files, mutexes, threads, events etc).

The reason why it rarely manifests itself is due to a race between the finializer thread and the
main thread during shutdown. Main thread gives finalizer thread 2000 ms to complete its work and
if it’s time outs, the main thread won’t call the code that will run the finalizers,
mono_gc_finalize_threadpool_threads for the thread objects added to an internal list
by the finalizer thread, so if the finalizer takes more than 2000 ms to complete during shutdown
the bug won’t manifest itself. By increasing the wait time in mono_domain_finalize to for example INFINITE,
the repro of this bug will be 100% and not timing dependent anymore.

Turns out that the offending CloseHandle on the thread object happens at an
earlier point in time during shutdown, when mono_thread_manage tries to wait for
threads to complete manage thread it will do remove_and_abort_threads for background
threads still around. The way this works is that it will setup a list of thread handles
that it will wait for using WaitForMultipleObjects and then close the handles.
It turns out that the implementation of remove_and_abort_threads adds the wrong
handle to the list, not the duplicated handle but the original thread handle,
and that will trigger this bug, since the original thread handle will be closed
(and the duplicated handle will leak). The fix is to use the duplicated thread
handle instead of the original, similar to how it was already done in other similar methods, like build_wait_tids.
Sinces this bug seems to been around for quite some time and is a race related to managed threads and mono
shutdown sequence it could give other weird side effects on windows during shutdown
(since it could have closed a random WIN32 object instead of the intended thread).

Looking at Bugzilla, there is one bug that very well could be related to this specific problem, 10108:

https://bugzilla.xamarin.com/show_bug.cgi?id=10108

This bug should most likely be retested with this fix to see if it still reproducible once merged into master.
2016-05-18 12:20:55 +02:00
Jo Shields 0ad934fb25 [jenkins] Use mingw64 to build, not 32 2016-05-18 10:48:01 +01:00
Miguel de Icaza d57d91565b [genproj] Updates to project generator and csproj files.
* Adds support for a handful of new command line arguments that we now use in the build.

* Always attempts to match to a project name, to get the proper project dependency.

* Update to support .exe and .dll in the generation.

* Remove warnings and some dead code

* Update the resulting csproj files based on running:

make update-csproj
make package-inputs
mono genproj.exe
2016-05-17 21:31:14 -04:00
Rodrigo Kumpera f1bc138d68 Merge pull request #3004 from xmcclure/gc-bridge-various
Various GC bridge cleanup from looking at bug #40844
2016-05-17 16:49:12 -07:00
Ludovic Henry 4f678b2ab0 [runtime] Remove support for NaCl 2016-05-17 17:43:37 -04:00
Alexis Christoforides d1c2c7172d Merge pull request #2250 from esdrubal/master
[System] Check SocketOptionName.ReuseAddress support.
2016-05-17 16:36:14 -04:00
Andi McClure 30967bc73c Add some comments in new/old gc bridges 2016-05-17 13:23:02 -04:00
Andi McClure 1189773812 Fix error message in sgen-bridge which does not list all options 2016-05-17 12:47:35 -04:00
Andi McClure 5bb6b470bc Remove redundant flag set in sgen-tarjan-bridge
bridge_processing_in_progress is set by sgen-tarjan-bridge.c at the
start and end of each bridge, although sgen-bridge sets this flag at
the same time.
2016-05-17 12:47:05 -04:00
Andi McClure 30cc8f4fd2 More accurate trace reporting duration of android gc bridge
There is some code that reports the length of a gc bridge operation in
sgen-stw. This is dead code dating from a period when gc bridges
occurred synchronously as part of a stop the world operation. The new
code globally tracks the end of the last stw and reports time since
then when the bridge thread completes.
2016-05-17 12:45:49 -04:00
Alexander Köplinger 066284a9ca Merge pull request #2979 from akoeplinger/tests-simplify
[tests] Simplify 'test-sgen' target logic in Makefile.am
2016-05-17 18:09:38 +02:00
Marek Habersack 977199d9e2 Merge pull request #2988 from radical/xbuild-fix-processwrapper
[xbuild] Fix ProcessWrapper to WaitForExit(..) before accessing ExitCode
2016-05-17 17:54:11 +02:00
Miguel de Icaza c101aaa155 Change Url for raw runtimes 2016-05-16 22:07:06 -04:00
Miguel de Icaza ad9b308279 Fix man page 2016-05-16 22:06:56 -04:00
Aleksey Kliger bb7e3289ed [runtime] MonoError-ize mono_compile_method
Mark it external only.  Runtime should use mono_compile_method_checked.
2016-05-16 19:10:54 -04:00
Aleksey Kliger (λgeek) 937968f14a Merge pull request #3001 from ludovic-henry/coop-blocking-rename
[coop] Use GC safe/unsafe macros inside the runtime
2016-05-16 18:33:18 -04:00
Alexander Köplinger 73b9bd1ddd Merge pull request #2987 from spouliot/ipv6only
[System][tests] Tweak Dns unit tests so it does not fail on an IPv6 only network
2016-05-16 23:33:14 +02:00
Zoltan Varga 536046d860 [arm] Align the stack to 16 bytes in mono_arch_get_call_filter () so it works on watchos. 2016-05-16 17:02:07 -04:00
Ludovic Henry 5674f16357 [coop] Use GC safe/unsafe macros inside the runtime
This allow the removal of MONO_(PREPARE|FINISH)BLOCKING and MONO(PREPARE|FINISH)_RESET_BLOCKING, which were not explicit in their intent, leading to confusion. This also harmonize how the product and the runtime transition between thread states.
2016-05-16 16:26:52 -04:00
Rodrigo Kumpera 0d9b17942f Merge pull request #2969 from ludovic-henry/coop-no-try-finally
[coop] Remove try { ... } finally { ... } blocks from wrappers + Fix state transitions in trampolines
2016-05-16 13:05:53 -07:00
Marek Safar b96de28591 Merge pull request #2999 from marek-safar/rs-FileWeb
[System] FileWebResponse/FileWebRequest from referencesource
2016-05-16 21:42:51 +02:00
Alexander Köplinger e5f5e64254 [System] Use common assertion api in IPAdressTest to fix monodroid build
`Assertion.Fail` isn't supported by NUnitLite in monodroid, use `Assert` instead to fix the build:

```
[12:29:46] /Users/builder/data/lanes/1845/88dbce4e/source/monodroid/tests/bcl-test/BclTests.csproj (default targets) ->
[12:29:46] /Library/Frameworks/Mono.framework/Versions/4.2.1/lib/mono/4.5/Microsoft.CSharp.Targets (CoreCompile target) ->
[12:29:46] 
[12:29:46] 	src/System/Test/System.Net/IPAddressTest.cs(282,4): error CS0103: The name `Assertion' does not exist in the current context
[12:29:46] 
[12:29:46] 	 14 Warning(s)
[12:29:46] 	 1 Error(s)
```
2016-05-16 21:05:58 +02:00
Marek Safar c1f06f09e2 [System] FileWebResponse/FileWebRequest from referencesource 2016-05-16 18:09:13 +02:00
Ludovic Henry 36e585e6bf [coop] Ensure exception handling is done in GC unsafe mode 2016-05-16 10:57:02 -04:00
Ludovic Henry 31ecf06447 [debug] Print MonoMethod pointer in mono_pmip output 2016-05-16 10:57:02 -04:00
Ludovic Henry 71dd4095a0 [coop] Assert that trampolines are called from GC unsafe code 2016-05-16 10:57:02 -04:00
Ludovic Henry adc2d06ddf [coop] The magic trampoline might be called from BLOCKING state 2016-05-16 10:57:02 -04:00
Ludovic Henry 5ed682646f [coop] Add default ftnptr eh callback 2016-05-16 10:57:02 -04:00
Ludovic Henry 1099ab5a14 [coop] Use unbalanced state switching functions for managed-to-native wrapper 2016-05-16 10:57:02 -04:00
Ludovic Henry 00af262fe2 [coop] Add possibly unbalanced state switching functions
This will be used by managed-to-native and native-to-managed wrappers, as well as trampolines, to switch between states. This is necessary as their calls might be unbalanced (a prepare blocking, without the corresponding finish blocking).
2016-05-16 10:57:02 -04:00
Ludovic Henry a34627addf [coop] Throw exception from finally clause in native-to-managed wrapper
If we do not throw it from the finally clause, then in case of a Thread.Abort, we will not rethrow the catched exception, but the ThreadAbortException, and this without using the callback, leading to native stack unwinding.
2016-05-16 10:57:02 -04:00
Ludovic Henry a936d1d021 [coop] Remove try { ... } finally { ... } from managed-to-native wrapper 2016-05-16 10:57:02 -04:00
Ludovic Henry 150d896d19 [coop] Remove support for invoke thunk wrapper
The support will be broken when we will introduce MonoHandle, as we can't pass the exception naked object ref around, but need to wrap it in a MonoHandle, while still in RUNNING mode.
2016-05-16 10:57:02 -04:00
Aleksey Kliger (λgeek) 88dbce4ebc Merge pull request #2993 from lambdageek/dev/monoerror-mono_string_from_utf16
[runtime] MonoError-ize mono_string_from_utf16
2016-05-16 10:13:19 -04:00
Marek Safar 13a64c5dab [System] Fixes build 2016-05-16 13:38:17 +02:00
Marek Safar c92f928ff8 [System] Authorization from referencesource 2016-05-16 12:13:52 +02:00
Marek Safar 86462930c9 Merge pull request #2995 from marek-safar/rs-IPAddress
[System] IPAddress from referencesource
2016-05-16 11:07:38 +02:00
lateralusX 8e1fe02546 Windows x64 full AOT support for mono/mini regression tests.
Fixes needed in order to get full AOT working for mono/mini regression tests on windows x64 builds (currently disabling the gsharedvt and dyncall tests).

Fixes are done in two main areas, exception and thread local storage support.

SEH exception handling enabled in order to catch CPU generated exceptions. All exception related regression tests pass with fix and runtime won't attempt to JIT any code since it is prevented when running with --full-aot startup argument.

Thread local storage (TLS) support was not complete on windows x64. When running full AOT the sgen allocator uses TLS for its allocator. AOT compiler will issues OP_TLS_GET_REG operations when compiling the “Alloc” methods. On win x64 this was not implemented, just the default OP_TLS_GET, meaning that methods compiled using OP_TLS_GET_REG was "silently" dropped when full AOT:ed compiled. At runtime, the sgen allocator would tried to locate the “Alloc” method but fails to find it and since this will cause an exception (that also needs the allocator to be used) and the program entered a loop that will end in a stack overflow crashing the program.

The fix implements OP_TLS_GET_REG and other needed support for win x64. It also fixes the offset calculation needed by full AOT builds (translating to correct runtime TLS key) for keys used by mono/mini regression tests. Since windows TLS support is a little more complex (two different conditions depending on where the TLS key gets allocated) the max size of tls_get_reg for amd64 has been increased from 32 to 64 byte as well.
2016-05-16 10:31:38 +02:00
Zoltan Varga fd4faf475b [reflection] Avoid force-setting klass->has_finalize for dynamic classes, compute it normally. Fixes #40953. (#2997) 2016-05-15 05:18:21 -04:00
Zoltan Varga 7e899a93fa [llvmonly] Avoid generating gsharedvt out wrappers for non-generic signatures. 2016-05-14 17:44:58 -04:00
Ivo Smits 31142140da Generate RSA keys using public exponent 65537 (was 17)
OpenSSL and the MS RSA CSP (Win7 x64) generate RSA keys with a public exponent of 65537. Smaller public exponents are not allowed by some specifications and may be rejected by other software.
2016-05-14 15:05:52 +02:00
Miguel de Icaza 2e3c90564a mkbundle commands for cross compilation. (#2970)
* Start of packager for mkbundle

* [mkbundle] Add fingerprint and directory at end of package

* [mkbundle] Update embedding file format, add support for --options, support for --runtime, chmod +x

* [driver] Add a way to parse arbitrary command line options

* [mkbundle] Align the assemblies on a page boundary, do not release directory buffer

* Work-around odd compiler error by using memcpy

* Update makefile

* Fix the windows build

* [Windows] Export the new mono_parse_options_from API

* Implement the various cross-compiler target fetching commands

* Clean
2016-05-13 21:32:14 -07:00
Marek Safar 008f7272d3 [System] IPAddress from referencesource 2016-05-13 18:14:56 +02:00
Marek Safar cc3f4c6037 [System] Replace few System.Net types with referencesource 2016-05-13 18:09:51 +02:00
Zoltan Varga 10ade09940 [coop] Avoid calling mono_marshal_set_last_error () in the managed-to-native wrapper inside the blocking block. Also make sure the prepare/finish_blocking jit icalls have no wrappers, so calling them doesn't involve trampolines. 2016-05-13 11:35:27 -04:00
Aleksey Kliger (λgeek) 022dd1d160 Merge pull request #2974 from lambdageek/dev/monoerror-misc_fixes
[runtime] Eliminate some mono_error_raise_exception calls
2016-05-13 11:07:00 -04:00
Zoltan Varga 9db20c4c04 Fix a warning. 2016-05-13 10:11:01 -04:00
Zoltan Varga a0ac9b08a5 [llvmonly] Make sure that linkonce methods need no initialization since they could be called before the AOT module they belong to is loaded. Still not enabled, since they seem to actually increase executable size. 2016-05-13 10:09:37 -04:00
Marek Safar 0f9ea1a279 [System] Remove unused files 2016-05-13 14:06:47 +02:00
Aleksey Kliger 9ace789ec9 [runtime] MonoError-ize mono_string_from_utf16
Marked it external only.  Runtime should use mono_string_from_utf16_checked

Also mark mono_string_from_utf32 as external only.

(It's currently unused in the runtime, but in the future
 mono_string_from_utf32_checked is available)
2016-05-12 17:43:43 -04:00
Marek Safar 7c4fb8caf0 Merge pull request #2984 from amccague/ping-task-fix
Resolved bug (8554) with Task Based Ping API
2016-05-12 23:24:05 +02:00
Alexander Köplinger 4b2901be9f Merge pull request #2990 from akoeplinger/fix-fsharp
[bcl] Add stub Mono.Posix.dll to 4.0 folder so FSharp bootstrapping works
2016-05-12 18:01:32 +02:00
Zoltan Varga 97ee981022 [arm] Make sure MONO_CONTEXT_GET_CURRENT () sets sp to an aligned value on watchos. 2016-05-12 11:51:02 -04:00
Alexander Köplinger d2d32de261 [bcl] Add stub Mono.Posix.dll to 4.0 folder so FSharp bootstrapping works
It was checking the existence of the file which doesn't work anymore after the -api rename.
This was already fixed upstream in https://github.com/fsharp/fsharp/pull/525 but the bootstrap package doesn't have the fix yet.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=41052
2016-05-12 17:48:26 +02:00
Aleksey Kliger 9f08e118d7 [runtime] MonoError-ize mono_mlist_{alloc,prepend,append}
Mark the various functions external only.  Runtime should use the
_checked variants.
2016-05-12 11:16:31 -04:00
Aleksey Kliger 45928aa532 [runtime] Eliminate some uses of mono_error_raise_exception 2016-05-12 11:16:31 -04:00
Aleksey Kliger 7e4a2c74db [cominterop] Get rid of uses of mono_error_raise_exception
in icalls
2016-05-12 11:15:28 -04:00
Aleksey Kliger fdcb21b071 [cominterop] MonoError-ize mono_string_from_bstr
Runtime should use mono_string_from_bstr_checked. The icall is
mono_string_from_bstr_icall. Marked mono_string_from_bstr external only.
2016-05-12 11:15:28 -04:00
Zoltan Varga 405bf02e72 Fix an bug added by 5b9f9751ba. 2016-05-12 10:01:51 -04:00
Alex Rønne Petersen ce381295d9 Merge pull request #2853 from alexrp/thread-name-improvements
More thread name improvements
2016-05-12 14:14:30 +02:00
Alex Rønne Petersen 828e6451c8 [threads] Add a missing mono_hazard_pointer_clear () in thread_cleanup (). 2016-05-12 14:12:24 +02:00
Alex Rønne Petersen ee47a43002 [threads] mono_thread_set_name_internal (): Rename 'managed' arg to 'permanent'.
The actual meaning is about whether or not the name is allowed to change after
having been set by the mono_thread_set_name_internal () call; it has nothing to
do with whether the call came from managed per se.
2016-05-12 14:12:23 +02:00
Alex Rønne Petersen 92664ed7ab [threads] Don't consider MONO_THREAD_FLAG_NAME_SET when setting thread name at thread startup.
If we did consider this, an internal runtime thread that had its name set by a
mono_thread_set_name_internal (..., FALSE /*managed*/, ...) call prior to
starting would not have its native name set nor its name reported to the
profiler.
2016-05-12 14:12:23 +02:00
Alex Rønne Petersen 373c59f3b7 [threads] Don't exempt thread pool threads from the 'name already set' check + exception.
MS.NET doesn't, so we shouldn't either.

Bug: https://bugzilla.xamarin.com/show_bug.cgi?id=23206
2016-05-12 14:12:22 +02:00
Alex Rønne Petersen 3e56d1901c [threads] Only mark a thread as having a name set if the given name is non-null.
This is consistent with MS.NET behavior.
2016-05-12 14:12:22 +02:00
Alex Rønne Petersen e598bc1ef5 [threads] Rename mono_thread_info_set_name () to mono_native_thread_set_name ().
This function has nothing to do with MonoThreadInfo structures, so the name is
somewhat misleading. It only requires a native thread ID.
2016-05-12 14:12:18 +02:00
Alex Rønne Petersen 595ebeeaef [domain] Remove an unnecessary call to mono_thread_info_set_name ().
We now do this in the thread main function.
2016-05-12 14:01:26 +02:00
Rolf Bjarne Kvinge da3cc8deb7 Bump nunit-lite to get compiler warning fix.
commit //github.com/mono/NUnitLite@7065bc89e8661cad447140752c0fce118644e06e
Author: Rolf Bjarne Kvinge <[email protected]>
Date:   Thu May 12 12:30:28 2016 +0200

    Fix compiler warning.
2016-05-12 12:41:47 +02:00
Zoltan Varga fbf8838abd [arm] Implement a dummy version of MONO_CONTEXT_GET_CURRENT () on watchos, only the sp register is set, this is the only one needed by sgen. 2016-05-12 06:15:23 -04:00
Zoltan Varga f1837ef103 [arm] Fix the DISABLE_JIT build. 2016-05-12 03:52:17 -04:00
Zoltan Varga 5b9f9751ba [aot] Add some MonoError machinery to aot-runtime.c. 2016-05-11 22:31:22 -04:00
Sebastien Pouliot 4d3ebc5a19 [System][tests] Make sure Dns tests works in a mixed IPv4/IPv6 network too
Previous tweak could disable some tests in a mixed network, e.g.
if an IPv6 address was first but an IPv4 address was available.
2016-05-11 17:50:01 -04:00
Ankit Jain d47f479ba4 [xbuild] Fix ProcessWrapper to WaitForExit(..) before accessing ExitCode
Process.Exited event can get invoked before the process has really
exited. So, accessing process.ExitCode before the real exit can throw:

Error executing task Exec: System.InvalidOperationException: Process must exit before requested information can be determined.
  at System.Diagnostics.Process.EnsureState (System.Diagnostics.Process+State state) [0x000b9] in /Users/ankit/dev/mono/mcs/class/referencesource/System/services/monitoring/system/diagnosticts/Process.cs:1439
  at System.Diagnostics.Process.get_ExitCode () [0x00000] in /Users/ankit/dev/mono/mcs/class/referencesource/System/services/monitoring/system/diagnosticts/Process.cs:219
  at (wrapper remoting-invoke-with-check) System.Diagnostics.Process:get_ExitCode ()
  at Microsoft.Build.Utilities.ToolTask.ExecuteTool (System.String pathToTool, System.String responseFileCommands, System.String commandLineCommands) [0x00101] in /Users/ankit/dev/mono/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/ToolTask.cs:185
  at Microsoft.Build.Tasks.Exec.ExecuteTool (System.String pathToTool, System.String responseFileCommands, System.String commandLineCommands) [0x00026] in /Users/ankit/dev/mono/mcs/class/Microsoft.Build.Tasks/Microsoft.Build.Tasks/Exec.cs:83
  at Microsoft.Build.Utilities.ToolTask.Execute () [0x0001c] in /Users/ankit/dev/mono/mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/ToolTask.cs:128
  at Microsoft.Build.BuildEngine.TaskEngine.Execute () [0x00000] in /Users/ankit/dev/mono/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/TaskEngine.cs:134
  at Microsoft.Build.BuildEngine.BuildTask.Execute () [0x0008f] in /Users/ankit/dev/mono/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildTask.cs:101

ProcessWrapper.WaitForOutput depends on the
`endEventExit`(ManualResetEvent) to be set, which is done in the event
handler for Process.Exited . So, effectively, WaitForOutput can return
before the process has really exited and ToolTask ends up throwing an
exception when it accesses the ExitCode.

Fix: Add a WaitForExit in WaitForOutput, to be sure!
2016-05-11 17:43:23 -04:00
Vlad Brezae 3c2fd4f371 Merge pull request #2971 from BrzVlad/feature-cross-binprot
[sgen] Cross platform binary protocol grep
2016-05-11 22:37:35 +03:00
Alexander Köplinger 0b8de1daf4 Merge pull request #2986 from akoeplinger/fix-mono310-bootstrapping
[System] Rename variable to fix bootstrapping with Mono 3.10 mcs
2016-05-11 21:29:21 +02:00
Marek Safar 93efeaebd5 [corlib] Put back instance creation using activation attributes. Fixes #40758 2016-05-11 18:27:40 +02:00
Ludovic Henry 7cb3a53502 Merge pull request #2982 from ludovic-henry/fix-cross-monocontext
Revert "[MonoContext] Make cross compiler a specific case"
2016-05-11 11:09:49 -04:00
Sebastien Pouliot 2114a13b23 [System][tests] Tweak Dns unit tests so it does not fail on an IPv6 only network
Some existing tests only works when IPv4 is available, which was fine as
it match how we historically ran those tests.

Apple has a new requirement [1] to test under an "IPv6 only network" and
the change facilitate this.

[1] https://developer.apple.com/news/?id=05042016a
2016-05-11 09:11:17 -04:00
Alexander Köplinger 04dcc661c6 Merge pull request #2985 from akoeplinger/fix-bug39305
[corlib] Make CountdownEventTests.Signal_Concurrent more reliable
2016-05-11 14:57:20 +02:00
Zoltan Varga c78cc36a0f [arm] Implement hardfp support in gsharedvt. Store the caller/callee CallInfo into GSharedVtCallInfo and iterate over it instead of extending the slot based code for simplicity. 2016-05-11 12:55:47 +00:00
Alexander Köplinger b56e03aa19 [System] Rename variable to fix bootstrapping with Mono 3.10 mcs
We were seeing compilation errors like this:

```
System.Security.Cryptography.X509Certificates/X509EnhancedKeyUsageExtension.cs(71,20): error CS0135: `oid' conflicts with a declaration in a child block
System.Security.Cryptography.X509Certificates/X509EnhancedKeyUsageExtension.cs(74,17): (Location of the symbol related to previous error)
Compilation failed: 1 error(s), 38 warnings
make[9]: *** [../../class/lib/basic/secxml/System.dll] Error 1
```

The new foreach variables introduced in 4a6e5d24e1 with the same "oid" name as the global constant apparently confused the older mcs compiler.

Rename them to avoid this.
2016-05-11 14:37:24 +02:00
Alexander Köplinger 5745b945a2 [corlib] Make CountdownEventTests.Signal_Concurrent more reliable
We were seeing random failures of the test in the iOS simulator and devices.

Looking at the test, it seems to me like the 1000ms timeout is just too short. In a single iteration we're
enqueuing 500 threadpool workitems and effectively give each of them just 2ms to run and signal the CountdownEvent.

Indeed I can easily repro this in the simulator on my box if I lower the timeout to 900ms.
This may be a side effect of the new threadpool which starts threads more conservatively afaik.

Bumping the timeout should fix this.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=39305
2016-05-11 14:12:28 +02:00
amccague c025009af8 Task Based Ping - removed illegal use of ?. 2016-05-11 13:06:15 +01:00
amccague a342863ba1 Resolved bug (8554) with Task Based Ping API
https://bugzilla.xamarin.com/show_bug.cgi?id=8554

Added unit tests to cover the Asynchronous API and the Task Based API.

Fixed an issue with the Task Based API that would previously throw a
`NullReferenceException` when started as the `CancellationTokenSource`
was not instantiated.
The `CancellationTokenSource` was also not disposed of after use.
2016-05-11 12:23:05 +01:00
amccague b1a2ead659 Merge remote-tracking branch 'mono/master' into ping-task-fix 2016-05-11 12:04:53 +01:00
Marek Safar 9c20705142 Merge pull request #2973 from marek-safar/rs-Uri
[System] Uri handling from reference source
2016-05-11 12:23:48 +02:00
Marek Safar 0c44dca122 [System] Uri handling from reference source
Fixes many issues in our uri handling
2016-05-11 09:59:46 +02:00
Zoltan Varga a5a388c82b [arm] Remove the unfinished nacl codegen code. 2016-05-11 07:36:20 +00:00
Zoltan Varga 73476d6b25 [arm] Implement hardfp support for dyncalls. 2016-05-11 07:18:24 +00:00
Zoltan Varga 3e78728d42 [arm] Fix float32 + hardfp support. 2016-05-11 06:38:08 +00:00
Aleksey Kliger (λgeek) b7f0eb2352 Merge pull request #2983 from akoeplinger/fix-bug40462
[corlib] Ignore DirectoryNotFoundException in FileStreamTest.OpenCharDeviceRepeatedly test
2016-05-10 17:06:54 -04:00
Ludovic Henry c520a61c43 [MonoContext] Fix sgen STW cross compilation 2016-05-10 15:45:45 -04:00
Alexander Köplinger 8fd52718cf [corlib] Ignore DirectoryNotFoundException in FileStreamTest.OpenCharDeviceRepeatedly test
It seems that older iOS6 devices don't allow access to /dev, as a DirectoryNotFoundException is
thrown when accessing /dev/zero in the FileStreamTest.OpenCharDeviceRepeatedly test there.

Ignore this exception and the test in those cases.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=40462
2016-05-10 21:05:32 +02:00
Ludovic Henry 1832571ad8 Revert "[MonoContext] Make cross compiler a specific case"
This reverts commit 09ae5b01c1.

This would break the XA and XI builds
2016-05-10 14:31:20 -04:00
Marek Safar 4176bb2dae Merge pull request #2981 from rolfbjarne/fix-rebuild-offsets-tool
[offsets-tool] Only create the .stamp-clone file if the clone succeeds.
2016-05-10 20:12:51 +02:00
Rolf Bjarne Kvinge cde9cf18cb [offsets-tool] Only create the .stamp-clone file if the clone succeeds.
This makes rebuilds work if the clone was cancelled.
2016-05-10 19:56:48 +02:00
Martin Baulig 5a701f39c7 [System]: Lazy-init X509ChainPolicy.ExtraStore when called from SystemCertificateValidator. Fixes #40899.
AppleTLS supports a lazily-initialized X509Certificate, but not X509Certificate2 so
we need to fall-back to using Mono.Security.X509 whenever we need an X509Certificate2.
To avoid unnecessary fallbacks, the private Mono.Net.Security APIs use X509Certificate
instead of X509Certificate2.

Since 'ExtraStore' returns X509Certificate2Collection, we need to convert these to
X509Certificate2.

(cherry picked from commit 05e2372339)
2016-05-10 13:40:33 -04:00
Ludovic Henry 22f277ad8d Merge pull request #2978 from ludovic-henry/coop-fix-reset-blocking
[threads] Fix reset blocking state transition
2016-05-10 13:38:02 -04:00
amccague f5e911b6b7 Merge remote-tracking branch 'mono/master' into ping-task-fix 2016-05-10 17:27:56 +01:00
Marek Safar 9324584359 Merge pull request #2933 from ludovic-henry/referencesource-monitor
[corlib] Import System.Threading.Monitor
2016-05-10 17:50:11 +02:00
Marek Safar 84e33bab27 [mcs] More tweaks to undefined tie-breaking rules. Fixes #40945 2016-05-10 17:38:04 +02:00
Zoltan Varga 1dbc9ab66b [llvmonly] Avoid sharing refs and intptrs in gsharedvt wrappers, it doesn't work yet. 2016-05-10 05:59:51 -04:00
Zoltan Varga 5f217496bc [llvmonly] Disable linkonce methods, they don't work yet. 2016-05-10 05:57:25 -04:00
Zoltan Varga 2e23232e33 [runtime] Check for a null argument in mono_monitor_enter_v4_fast () before calling mono_monitor_try_enter_internal (), the latter would set a pending exception, but the JITted code calling enter_v4_fast () doesn't check for it. 2016-05-10 02:17:49 -04:00
Zoltan Varga c42ecf6144 [jit] Set the real_offset of inlined bblocks to the il offset where the method was inlined, so get_most_deep_clause () in llvm works correctly with inlined methods. 2016-05-10 01:58:14 -04:00
Zoltan Varga 907d67487e [llvmonly] Transform the error returned by init_method () into an exception and throw it, it can be an exception thrown by a cctor. 2016-05-10 01:58:14 -04:00
Alexander Köplinger 274a79653a [tests] Simplify 'test-sgen' target logic in Makefile.am
The sgen tests should run on Windows x86 too (or at least they will in the near future), so we can get rid of all the special casing.
This also fixes an error in the ARM64 test run on Jenkins because test-sgen wasn't defined there.
2016-05-10 02:36:47 +02:00
Vlad Brezae 37006b206e [sgen] Support binary protocol cross platform grep-ing across platforms with unequal word sizes 2016-05-10 02:32:54 +03:00
Vlad Brezae 3eb249ce86 [sgen] Pack structs for binary protocol entries
We save space and support cross platform grep-ing across platforms with the same word size.
2016-05-10 02:31:43 +03:00
Vlad Brezae 932d9b3115 [sgen] Split protocol entry grep from argument parsing 2016-05-10 02:31:42 +03:00
Vlad Brezae 6b35377caa [sgen] Extract entry stream code into new file 2016-05-10 02:31:42 +03:00
Vlad Brezae 8e469b9d3d [sgen] Use types with explicit size for protocol entries, on the reader end 2016-05-10 02:31:40 +03:00
Ludovic Henry 2653868a27 [threads] Fix reset blocking state transition
There would previously be a race between reset blocking and a STW, that would happen as follow:
 - T1 goes into blocking - T1 state is BLOCKING(0)
 - T2 suspends T1  - T1 state is BLOCKING(1)
 - T1 does a reset blocking -> T1 state is SELF SUSPEND REQUESTED
 - T2 calls `mono_thread_info_get_suspend_state` on T1 --- SIGABRT as we cannot get suspend state when state is SELF SUSPEND REQUESTED
 - T1 does polling -> T1 state is SELF SUSPENDED

The fix is for reset blocking to work like done blocking: switch to BLOCKING AND SUSPENDED.
2016-05-09 19:10:43 -04:00
Alexander Köplinger 5099acaed4 Use available memory instead of physical memory as metric for allocation-heavy tests
We were seeing issues on the new Jenkins Azure boxes which had 7GB of physical memory but only about 1GB free at the time of the test, so it'd fail.
Checking the available memory should fix this.
2016-05-10 00:26:04 +02:00
Aleksey Kliger (λgeek) 65ab352de4 Merge pull request #2967 from lambdageek/dev/coop-threadpool-exceptions5
[runtime] Pending exception takes precedence over Thread.Abort ()
2016-05-09 15:11:47 -04:00
Aleksey Kliger (λgeek) 8ce78a5bd5 Merge pull request #2954 from lambdageek/dev/monoerror-field_static_get_value
MonoError for mono_field_static_get_value
2016-05-09 14:56:50 -04:00
Neale Ferguson 3f880e2bcf Fix checking of header environment variable 2016-05-09 12:57:38 -04:00
Aleksey Kliger 701965dc26 [runtime] Pending exception takes precedence over Thread.Abort ()
If there's a pending exception and an AbortRequested, the pending
excpetion should be thrown.

This fixes threadpool-exceptions5.cs in coop mode.

There are two situations where this could happen.

1. Like threadpool-exception5.cs we have a threadpool worker thread
  request an abort and then its async callback runs and throws an
  exception.  In this case apparently the async callback's exception
  should be allowed to unwind and hit the unhandled exception handler.

2. A thread catches ThreadAbortException and then posts a pending
  exception of some other excpetion from the catch clause.  In this case
  we unwind that other exception, and when it's caught we rethrow the
  abort.
2016-05-09 12:13:33 -04:00
Marek Safar 93b11fcdc9 [System] Cleanup uri tests 2016-05-09 17:39:13 +02:00
Aleksey Kliger 57b1ae750f [runtime] MonoError-ize mono_field_static_get_value
Mark it external only.  Runtime should use mono_field_static_get_value_checked.
2016-05-09 11:04:43 -04:00
Aleksey Kliger 30cebd4c3f [runtime] MonoError-ize mono_field_static_get_value_for_thread 2016-05-09 11:04:43 -04:00
Aleksey Kliger e027a53e15 [runtime] MonoError-ize get_default_field_value 2016-05-09 11:04:43 -04:00
Aleksey Kliger 488b3a09e9 [runtime] MonoError-ize mono_get_constant_value_from_blob 2016-05-09 11:04:43 -04:00
Zoltan Varga 55e3dbe9cb [arm] Enable native types for Xamarin.WatchOS.dll too. Enable Unwind_Backtrace support on watchos. 2016-05-09 07:15:51 -04:00
Zoltan Varga b244fd9303 [llvm] Enable OP_LADD_OVF opcodes on 32 bit platforms too. Avoid optimizing long shift opcodes when using llvm. Enable support for hardfp calling conventions on arm. 2016-05-09 07:14:50 -04:00
Zoltan Varga f257b5b3eb [arm] Use the hardfp abi on watchos. 2016-05-09 07:11:21 -04:00
Zoltan Varga 120dcce23f [ppdb] Avoid using pdb files for assemblies which are not compiled by csc using /debug:portable. Fixes #40886. 2016-05-08 21:13:38 -04:00
Zoltan Varga 8891a6d142 [llvm] Add support for OP_GC_SAFE_POINT. 2016-05-08 18:51:49 -04:00
Zoltan Varga 3e844ddcda [arm] Align the stack correctly in the gsharedvt trampoline on platforms with frame alignment greater than 8 (watchos). 2016-05-06 18:22:42 -04:00
Zoltan Varga 6da2178dd8 [arm] Define MONO_ARCH_DISABLE_HW_TRAPS on watchos. 2016-05-06 18:22:42 -04:00
Martin Baulig 209c8fc0dd [System]: Fix certificate validation with empty hostname.
When the system certificate validator is invoked with an empty hostname
(caller does not want us to validate the hostname), then we need to pass
null to SecPolicyCreateSSL() and not the empty string.

(cherry picked from commit f29804d149)
2016-05-06 16:11:55 -04:00
Martin Baulig 352b979ccd [System]: Add comment to the obsoletion of Mono-specific ServicePointManager APIs.
(cherry picked from commit 1b4921b573)
2016-05-06 15:58:55 -04:00
Martin Baulig 8b8d688fef [System]: Obsolete the Mono-specific cipher suite callbacks in ServicePointManager.
(cherry picked from commit fa75386bb8)
2016-05-06 15:58:44 -04:00
Martin Baulig 67d87ebc1e [corlib]: Cleanup X509Helper.Import().
Only attempt the automatic PEM->DER conversion when no password was given
and make this version of X509Helper.Import() also take care of the fallback.

(cherry picked from commit 63a214c3f0)
2016-05-06 15:58:44 -04:00
Aleksey Kliger (λgeek) b5bde9cf42 Merge pull request #2968 from lambdageek/dev/coop-unify-jit_thread_attach
[runtime] Unify codepath in mono_jit_thread_attach
2016-05-06 13:33:38 -04:00
Aleksey Kliger 1775972396 [runtime] Unify codepath in mono_jit_thread_attach
Previously we had separate codepaths in mono_jit_thread_attach for coop
and non-coop modes.

Now there's a common codepath for attaching the thread, and separate
code paths for performing coop state machine transitions and computing
the return value cookie.

Fixes Mono.Debugger.Soft tests under coop.
2016-05-06 10:26:12 -04:00
Rodrigo Kumpera d36d16618f Merge pull request #2963 from ludovic-henry/fix-unified-suspend
[threads] Fix some unified suspend bugs
2016-05-05 19:21:56 -04:00
Ludovic Henry 8796c59f1c [sgen] Fix possible race condition between world stop and restart 2016-05-05 16:52:30 -04:00
Ludovic Henry 69e950a4b7 [sgen] Do not skip starting and detaching thread during suspend
By skipping thread which have a NULL domain or lmf, we would also skip threads which are in RUNNING mode, but which are still attaching to the runtime. They could have in practice called `mono_thread_info_attach`, without having executed any managed code or set a domain yet. Because we would simply discard the suspending for these threads, we could potentially not suspend them, meaning they would keep running, even potentially run some managed code, while the GC is still running.

To fix that, we need to slightly modify the expectation of sgen STW when using unified suspend. The non-unified expectation of sgen STW would be that even if a thread has a non-initialized domain or lmf, it should still be suspended, but not scanned. The unified expectation of sgen STW would be that if a thread has a non-initialized domain or lmf, then the thread shouldn't be suspended. That second behaviour works well if we only consider that the domain or lmf could be non-initialized when the thread is detaching, but that consideration is just wrong. The main example is the beginning of `start_wrapper_internal` (in threads.c:637), where we have non-initialized domain and lmf, but where the thread is in RUNNING state, and about to access some managed memory.
2016-05-05 16:52:30 -04:00
Ludovic Henry 73a74eb0d7 [threads] Correct comment 2016-05-05 16:50:45 -04:00
Ludovic Henry 01e9012f97 [sgen] Improve STW debugging output 2016-05-05 16:50:45 -04:00
Ludovic Henry 218d8617d1 [threads] Make debugging output consistent
Other THREAD_SUSPEND_DEBUG would print the native thread TID, instead of the MonoThreadInfo*
2016-05-05 16:50:45 -04:00
Ludovic Henry 5f9fdd4556 [threads] Increase state machine verbosity when crashing 2016-05-05 16:50:45 -04:00
Ludovic Henry 0df82bae4b [threads] Fix segfault 2016-05-05 16:49:59 -04:00
Ludovic Henry 443d9d9700 [suspend] Don't try to suspend an already suspended thread 2016-05-05 16:49:59 -04:00
Ludovic Henry 5ac3f66978 [threads] Fix compilation warning 2016-05-05 16:49:59 -04:00
Ludovic Henry afe5b55f31 [sgen] Add some assertion for stack start and end 2016-05-05 16:49:59 -04:00
Ludovic Henry 8585306f73 [tests] Add sgen-new-threads-dont-join-stw-2 2016-05-05 16:48:31 -04:00
Ludovic Henry b34681ec2f [threads] Be more verbose in the case of an error 2016-05-05 16:48:31 -04:00
Ludovic Henry 3a76359581 [runtime] Use utils mono_thread_info_yield 2016-05-05 16:48:31 -04:00
Vlad Brezae 7429b9e1c4 [sgen] Remove old unused defines 2016-05-05 23:32:00 +03:00
Ludovic Henry b6eeb4d398 Merge pull request #2948 from ludovic-henry/coop-n2m-eh-callback
[marshal] Add EH callback for native-to-managed wrapper
2016-05-05 15:18:44 -04:00
Aleksey Kliger (λgeek) f0ad12b3e6 Merge pull request #2965 from lambdageek/dev/checked-pinvoke3
[coop] Allow BLOCKING->DETACHED transition
2016-05-05 13:18:47 -04:00
Zoltan Varga ad78b9f5ac Fix the cross compiler build. 2016-05-05 13:10:41 -04:00
Ludovic Henry 3265991ed9 Merge pull request #2964 from ludovic-henry/sgen-monocontext
[MonoContext] Migrate remaining architectures + [sgen] Kill USE_MONO_CTX and ARCH_NUM_REGS
2016-05-05 08:46:12 -04:00
Marek Safar 73537bbf06 Merge pull request #2966 from marek-safar/oid
[System] Oid from referencesource
2016-05-05 09:15:14 +02:00
Martin Baulig 0adfeefedd [corlib]: Try to convert the certificate from PEM to DER in X509Helper.Import(). 2016-05-04 20:05:37 -04:00
Alex Rønne Petersen 4e751100fc Merge pull request #2928 from alexrp/master
[profiler] Fix profiler compilation under bitcode.
2016-05-05 00:52:19 +02:00
Marek Safar 4a6e5d24e1 [System] Oid from referencesource. Fixes #40646 and other incompabilities 2016-05-04 23:59:22 +02:00
Ludovic Henry 873e0145c3 [corlib] Import System.Threading.Monitor 2016-05-04 16:13:10 -04:00
Ludovic Henry 45b8807844 Merge pull request #2955 from ludovic-henry/mono_msec_ticks-overflow
[runtime] Fix potential overflow when using mono_msec_ticks
2016-05-04 16:01:16 -04:00
Aleksey Kliger 7841b0a319 [coop] Allow BLOCKING->DETACHED transition.
On coop, an OS thread can go
STARTING->BLOCKING->RUNNING->BLOCKING->DETACHED.

For ordinary managed threads BLOCKING->DETACHED is still a bug like
before, but hopefully the checked build machinery will help us to catch
those situations.
2016-05-04 14:58:26 -04:00
Aleksey Kliger c20d1a9479 [checked] Use correct reset blocking cookie when attaching OS threads
When checked build is running with GC checking, it uses a non-zero
integer cookie instead of the thread info pointer.

This fixes pinvoke3.cs test_43_thread_attach() in checked coop builds.
2016-05-04 14:58:26 -04:00
Ludovic Henry 6eae03402a [marshal] Add EH callback for native-to-managed wrapper
This is going to be used by Xamarin.iOS to convert a managed exception to an Obj-C exception. We need this as if we don't do that, the managed exception mechanism will unwind native stack, which can lead to undefined behavior. By converting to an Obj-C exception, we let the native exception mechanism do what it's supposed to do.
2016-05-04 12:05:47 -04:00
Ludovic Henry 45d7c18d23 [marhsal] Always generate try { ... } finally { ... } in native-to-managed wrapper 2016-05-04 11:59:20 -04:00
Ludovic Henry a665613192 [sgen] Kill USE_MONO_CTX and ARCH_NUM_REGS 2016-05-03 17:34:15 -04:00
Ludovic Henry 09ae5b01c1 [MonoContext] Make cross compiler a specific case 2016-05-03 17:14:57 -04:00
Ludovic Henry 2555869fcf [sgen] Make Sparc use MonoContext 2016-05-03 17:11:51 -04:00
Ludovic Henry f0a2c8ef30 [sgen] Make PowerPC use MonoContext 2016-05-03 17:11:49 -04:00
Ludovic Henry 71d181c3b3 [runtime] Fix potential overflow when using mono_msec_ticks
Because mono_msec_ticks would previously return the number of milliseconds since boot time, it would overflow after ~49 days. That would mean that anywhere you would use it, you would need to be careful of arithmetic overflow.

By simply returning a gint64 we will not overflow before ~30k years.

Fixes bug https://bugzilla.xamarin.com/show_bug.cgi?id=38666
2016-05-03 14:15:25 -04:00
Neale Ferguson 52dbd3576e Create entire line of output before writing - prevents need for locking or interspersed messages 2016-04-28 13:40:23 -04:00
Neale Ferguson d808b7a064 Add description of MONO_LOG_HEADER environment variable 2016-04-25 20:54:05 -04:00
Neale Ferguson f32457bd0b Add environment variable to control log header 2016-04-25 19:26:40 -04:00
Alex Rønne Petersen 6a25ee98dd [profiler] Remove unnecessary compiler flags related to exceptions. 2016-04-20 19:58:38 +02:00
Alex Rønne Petersen cfd9870f83 [profiler] Don't build shared libraries under bitcode.
We load these at runtime so they will naturally have undefined symbols. This is
not allowed under bitcode, though, and we use the static libraries in that case
anyway.
2016-04-20 19:57:53 +02:00
Alex Rønne Petersen 785c22693d [profiler] Build all profiler modules in the same way.
Specifically, we need to set the same linker flags for all of them. This should
fix linker errors on iOS ARM64.
2016-04-20 12:34:15 +02:00
Alex Rønne Petersen 10044cf0cd [profiler] Remove unused OProfile stuff from the build system. 2016-04-20 09:54:41 +02:00
Neale Ferguson a6bc6cda4a mono-threads.c - Use the environment variable (if set) to determine the abort time
libmonoutils.vcxproj - Add new logging source code files to the project
2016-03-18 16:28:40 -04:00
Neale Ferguson 76ce319312 Fix typos 2016-03-09 11:06:33 -05:00
Neale Ferguson 746971d090 Fix whitespace 2016-03-08 15:07:08 -05:00
Neale Ferguson 1ca9141f91 Correct entry point names 2016-03-08 15:04:28 -05:00
Neale Ferguson 76fe267817 Improve trace logging -
- Add logfile and syslog capability. For Windows, the latter is simulated by writing to a file. Adding Eventlog support is for a future effort. The choice of logging mode is made via MONO_LOG_DEST environment variable.
- Add timestamps and pid to the trace messages to make them more useful
- Add timestamps to SGEN_LOG
- Related to tracing: when tracing and using something like Valgrind the system may be slowed so much that the sleep abort limit may be exceeded for threads. This fix adds an environment variable lookup of "MONO_SLEEP_ABORT_LIMIT" which is a value greater than 40, which defines the number of milliseconds to wait for threads to complete pending operations. If not set, the valus is 200.
2016-03-08 14:54:11 -05:00
Marcos Henrich eddc210ec6 Check e.NativeErrorCode is SocketError.OperationNotSupported. 2016-02-17 09:56:16 +00:00
Marcos Henrich 91a6e35c9b Updated SocketTest.UdpDoubleBind 2016-02-17 09:56:15 +00:00
Marcos Henrich 9d3d44013f [System] Check SocketOptionName.ReuseAddress support.
Operating systems that use linux kernels before 3.9 do not support
binding multiple socket to the same address and port.

In those systems even if it was possible to set
SocketOptionName.ReuseAddress an exception was thrown on the second
bind.

These changes introduce a SocketException that is thrown when
SocketOptionName.ReuseAddress is set on a system that will fail to bind
multiple times to the same address.
2016-02-17 09:56:14 +00:00
1184 changed files with 50948 additions and 48028 deletions

No files matched your search

+18 -9
View File
@@ -4,18 +4,17 @@ AM_CFLAGS = $(WERROR_CFLAGS)
MONOTOUCH_SUBDIRS = $(libgc_dir) eglib/src mono
# Some tools might not build when cross-compiling
if CROSS_COMPILING
SUBDIRS = po $(libgc_dir) eglib mono $(ikvm_native_dir) support data runtime scripts man samples msvc $(docs_dir) acceptance-tests
# Keep in sync with SUBDIRS
## 'tools' is not normally built
DIST_SUBDIRS = m4 po $(libgc_dir) eglib mono ikvm-native support data runtime scripts man samples tools msvc docs acceptance-tests
tools_dir =
else
SUBDIRS = po $(libgc_dir) eglib mono $(ikvm_native_dir) support data runtime scripts man samples msvc $(docs_dir) acceptance-tests
# Keep in sync with SUBDIRS
## 'tools' is not normally built
DIST_SUBDIRS = m4 po $(libgc_dir) eglib mono ikvm-native support data runtime scripts man samples tools msvc docs acceptance-tests
tools_dir = tools
endif
SUBDIRS = po $(libgc_dir) eglib mono $(ikvm_native_dir) support data runtime scripts man samples $(tools_dir) msvc $(docs_dir) acceptance-tests llvm
# Keep in sync with SUBDIRS
DIST_SUBDIRS = m4 po $(libgc_dir) eglib mono ikvm-native support data runtime scripts man samples tools msvc docs acceptance-tests llvm
all: update_submodules
SUBMODULE_ERROR='Could not recursively update all git submodules. You may experience compilation problems if some submodules are out of date'
@@ -32,7 +31,8 @@ EXTRA_DIST= \
mono-uninstalled.pc.in \
winconfig.h \
code_of_conduct.md \
external
external \
mcs/class/referencesource
DISTCHECK_CONFIGURE_FLAGS = EXTERNAL_MCS=false EXTERNAL_RUNTIME=false
@@ -67,6 +67,10 @@ get-monolite-latest:
cd $(mcslib) && { (wget -O- $(monolite_url) || curl $(monolite_url)) | gzip -d | tar xf - ; }
cd $(mcslib) && mv -f monolite-* monolite
.PHONY: check-ci
check-ci:
MONO_LLVMONLY=$(MONO_LLVMONLY) $(srcdir)/scripts/ci/run-test-$(TEST_PROFILE).sh
.PHONY: validate do-build-mono-mcs mcs-do-clean mcs-do-tests
validate: do-build-mono-mcs
$(MAKE) mcs-do-tests
@@ -152,6 +156,7 @@ package-inputs:
read libou; echo " <library_output>$$libou</library_output>"; \
read fx_ver; echo " <fx_version>$$fx_ver</fx_version>"; \
read profile; echo " <profile>$$profile</profile>"; \
read resxt; echo " <resources>$$resxt</resources>"; \
read resp; echo " <response>$$resp</response>"; \
echo " </project>") >> msvc/scripts/order.xml; \
done
@@ -163,3 +168,7 @@ update-llvm-version:
REV=`$(LLVM_DIR)/bin/llvm-config --version` && sed -e "s,expected_llvm_version=.*,expected_llvm_version=\"$$REV\"," < configure.ac > tmp && mv tmp configure.ac && echo "Version set to $$REV."
update-solution-files:
make update-csproj
make package-inputs
(cd msvc/scripts; make genproj.exe; mono genproj.exe)
+36 -17
View File
@@ -19,28 +19,30 @@ The Mono project is part of the [.NET Foundation](http://www.dotnetfoundation.or
Officially supported architectures:
| debian-amd64 | debian-i386 | debian-armel | debian-armhf | windows-amd64 |
|-------------------------|------------------------|-------------------------|-------------------------|---------------------------|
| [![debian-amd64][1]][2] | [![debian-i386][3]][4] | [![debian-armel][5]][6] | [![debian-armhf][7]][8] | [![windows-amd64][9]][10] |
| ubuntu-1404-amd64 | ubuntu-1404-i386 | debian-8-armel | debian-8-armhf | debian-8-arm64 | windows-amd64 |
|------------------------------|-----------------------------|---------------------------|---------------------------|-----------------------------|----------------------------|
| [![ubuntu-1404-amd64][1]][2] | [![ubuntu-1404-i386][3]][4] | [![debian-8-armel][5]][6] | [![debian-8-armhf][7]][8] | [![debian-8-arm64][9]][10] | [![windows-amd64][11]][12] |
Community supported architectures:
| centos-s390x |
|---------------------------|
| [![centos-s390x][11]][12] |
| [![centos-s390x][13]][14] |
[1]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-amd64/badge/icon
[2]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-amd64/
[3]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-i386/badge/icon
[4]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-i386/
[5]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-armel/badge/icon
[6]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-armel/
[7]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-armhf/badge/icon
[8]: http://jenkins.mono-project.com/job/test-mono-mainline/label=debian-armhf/
[9]: https://ci.appveyor.com/api/projects/status/1e61ebdfpbiei58v/branch/master?svg=true
[10]: https://ci.appveyor.com/project/ajlennon/mono-817/branch/master
[11]: https://jenkins.mono-project.com/job/z/label=centos-s390x/badge/icon
[12]: https://jenkins.mono-project.com/job/z/label=centos-s390x
[1]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=ubuntu-1404-amd64/badge/icon
[2]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=ubuntu-1404-amd64
[3]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=ubuntu-1404-i386/badge/icon
[4]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=ubuntu-1404-i386/
[5]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-armel/badge/icon
[6]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-armel/
[7]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-armhf/badge/icon
[8]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-armhf/
[9]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-arm64/badge/icon
[10]: https://jenkins.mono-project.com/job/test-mono-mainline-linux/label=debian-8-arm64/
[11]: https://ci.appveyor.com/api/projects/status/1e61ebdfpbiei58v/branch/master?svg=true
[12]: https://ci.appveyor.com/project/ajlennon/mono-817/branch/master
[13]: https://jenkins.mono-project.com/job/z/label=centos-s390x/badge/icon
[14]: https://jenkins.mono-project.com/job/z/label=centos-s390x
Compilation and Installation
============================
@@ -517,7 +519,24 @@ See the LICENSE file for licensing information, and the PATENTS.TXT
file for information about Microsoft's patent grant.
Mono Trademark Use Policy
=======
=========================
The use of trademarks and logos for Mono can be found [here] (http://www.dotnetfoundation.org/legal/mono-tm).
Maintaining the Class Library Solution Files
============================================
Mono now ships with a solution file that can be used to build the
assemblies from an IDE. Either by opening the topmost `net_4_x.sln`
file, or to by loading one of the individual `csproj` files located in
each directory.
These are maintained by extracting the configuration information from
our Makefiles, which as of May 2016 remain the canonical location for
configuration information.
When changes are made to the Makefiles, a user would need to run the
following command to re-generate the solution files at the top level:
$ make update-solution-files
+1 -1
View File
@@ -4,7 +4,7 @@ CORECLR_PATH=$(ACCEPTANCE_TESTS_PATH)/coreclr
MSTESTSUITE_PATH=$(ACCEPTANCE_TESTS_PATH)/ms-test-suite
CLEANFILES = *.dll *.exe *.mdb
EXTRA_DIST=README.md SUBMODULES.json versions.mk versions.py roslyn.mk coreclr.mk ms-test-suite.mk
EXTRA_DIST=README.md SUBMODULES.json versions.mk roslyn.mk coreclr.mk ms-test-suite.mk
CLASS=$(mcs_topdir)/class/lib/$(DEFAULT_PROFILE)
+2 -2
View File
@@ -10,7 +10,7 @@
{
"name": "coreclr",
"url": "git://github.com/mono/coreclr.git",
"rev": "b05c242a59eab1c4ea2803960c8065167308546d",
"rev": "c7da48acf72c40c0c0ed1a80ebfacea21bb3a271",
"remote-branch": "origin/mono",
"branch": "mono",
"directory": "coreclr"
@@ -18,7 +18,7 @@
{
"name": "ms-test-suite",
"url": "[email protected]:xamarin/ms-test-suite.git",
"rev": "4a95604fdf2c0523e68eaad64a17d22eebb051b3",
"rev": "840653918efed24f00f5e166094f06354cae7255",
"remote-branch": "origin/master",
"branch": "master",
"directory": "ms-test-suite"
+1 -117
View File
@@ -1,127 +1,11 @@
.PHONY: validate-versions reset-versions
CONFIG=SUBMODULES.json
# usage $(call ValidateVersionTemplate (name,MAKEFILE VAR,repo name))
# usage $(call ValidateVersionTemplate (mono,MONO,mono))
define ValidateVersionTemplate
#$(eval REPOSITORY_$(2):=$(shell test -z $(3) && echo $(1) || echo "$(3)"))
#$(eval DIRECTORY_$(2):=$(shell python versions.py get-dir $(1)))
#$(eval DIRECTORY_$(2):=$(shell test -z $(DIRECTORY_$(2)) && echo $(1) || echo $(DIRECTORY_$(2))))
#$(eval MODULE_$(2):=$(shell python versions.py get-url $(1)))
#$(eval NEEDED_$(2)_VERSION:=$(shell python versions.py get-rev $(1)))
#$(eval $(2)_BRANCH_AND_REMOTE:=$(shell python versions.py get-remote-branch $(1)))
#$(eval $(2)_VERSION:=$$$$(shell cd $($(2)_PATH) 2>/dev/null && git rev-parse HEAD ))
#$(eval NEEDED_$(2)_BRANCH:=$(word 2, $(subst /, ,$($(2)_BRANCH_AND_REMOTE))))
#$(eval NEEDED_$(2)_REMOTE:=$(word 1, $(subst /, ,$($(2)_BRANCH_AND_REMOTE))))
#$(eval $(2)_BRANCH:=$$$$(shell cd $($(2)_PATH) 2>/dev/null && git symbolic-ref --short HEAD 2>/dev/null))
validate-$(1)::
@if test x$$(IGNORE_$(2)_VERSION) = "x"; then \
if test ! -d $($(2)_PATH); then \
if test x$$(RESET_VERSIONS) != "x"; then \
$(MAKE) reset-$(1) || exit 1; \
else \
echo "Your $(1) checkout is missing, please run 'make reset-$(1)'"; \
touch .validate-versions-failure; \
fi; \
else \
if test "x$($(2)_VERSION)" != "x$(NEEDED_$(2)_VERSION)" ; then \
if test x$$(RESET_VERSIONS) != "x"; then \
$(MAKE) reset-$(1) || exit 1; \
else \
echo "Your $(1) version is out of date, please run 'make reset-$(1)' (found $($(2)_VERSION), expected $(NEEDED_$(2)_VERSION))"; \
test -z "$(BUILD_REVISION)" || $(MAKE) test-$(1); \
touch .validate-versions-failure; \
fi; \
elif test "x$($(2)_BRANCH)" != "x$(NEEDED_$(2)_BRANCH)" ; then \
if test x$$(RESET_VERSIONS) != "x"; then \
test -z "$(BUILD_REVISION)" || $(MAKE) test-$(1); \
$(MAKE) reset-$(1) || exit 1; \
else \
echo "Your $(1) branch is out of date, please run 'make reset-$(1)' (found $($(2)_BRANCH), expected $(NEEDED_$(2)_BRANCH))"; \
touch .validate-versions-failure; \
fi; \
fi; \
fi; \
fi
test-$(1)::
@echo $(1)
@echo " REPOSITORY_$(2)=$(REPOSITORY_$(2))"
@echo " DIRECTORY_$(2)=$(DIRECTORY_$(2))"
@echo " MODULE_$(2)=$(MODULE_$(2))"
@echo " NEEDED_$(2)_VERSION=$(NEEDED_$(2)_VERSION)"
@echo " $(2)_VERSION=$($(2)_VERSION)"
@echo " $(2)_BRANCH_AND_REMOTE=$($(2)_BRANCH_AND_REMOTE)"
@echo " NEEDED_$(2)_BRANCH=$(NEEDED_$(2)_BRANCH)"
@echo " NEEDED_$(2)_REMOTE=$(NEEDED_$(2)_REMOTE)"
@echo " $(2)_BRANCH=$($(2)_BRANCH)"
@echo " $(2)_PATH=$($(2)_PATH) => $(abspath $($(2)_PATH))"
reset-$(1)::
@if test -d $($(2)_PATH); then \
if ! (cd $($(2)_PATH) && git show $(NEEDED_$(2)_VERSION) >/dev/null 2>&1 && git log -1 $(NEEDED_$(2)_REMOTE) >/dev/null 2>&1) ; then \
echo "*** git fetch `basename $$($(2)_PATH)`" && (cd $($(2)_PATH) && git fetch); \
fi; \
else \
echo "*** git clone $(MODULE_$(2)) --recursive $(DIRECTORY_$(2))" && (cd `dirname $($(2)_PATH)` && git clone $(MODULE_$(2)) --recursive $(DIRECTORY_$(2)) || exit 1 ); \
fi
@if test x$$(IGNORE_$(2)_VERSION) = "x"; then \
echo "*** [$(1)] git checkout -f" $(NEEDED_$(2)_BRANCH) && (cd $($(2)_PATH) ; git checkout -f $(NEEDED_$(2)_BRANCH) || git checkout -f -b $($(2)_BRANCH_AND_REMOTE)); \
echo "*** [$(1)] git reset --hard $(NEEDED_$(2)_VERSION)" && (cd $($(2)_PATH) && git reset --hard $(NEEDED_$(2)_VERSION)); \
fi
@echo "*** [$(1)] git submodule update --init --recursive" && (cd $($(2)_PATH) && git submodule update --init --recursive)
print-$(1)::
@printf "*** %-16s %-45s %s (%s)\n" "$(DIRECTORY_$(2))" "$(MODULE_$(2))" "$(NEEDED_$(2)_VERSION)" "$(NEEDED_$(2)_BRANCH)"
.PHONY: validate-$(1) reset-$(1) print-$(1)
reset-versions:: reset-$(1)
validate-versions:: Validate-$(1)
print-versions:: print-$(1)
endef
include $(top_srcdir)/scripts/submodules/versions.mk
$(eval $(call ValidateVersionTemplate,roslyn,ROSLYN))
$(eval $(call ValidateVersionTemplate,coreclr,CORECLR))
$(eval $(call ValidateVersionTemplate,ms-test-suite,MSTESTSUITE))
reset-versions::
validate-versions::
@if test -e .validate-versions-failure; then \
rm .validate-versions-failure; \
echo One or more modules needs update; \
exit 1; \
else \
echo All dependent modules up to date; \
fi
reset:
@$(MAKE) validate-versions RESET_VERSIONS=1
__bump-version-%:
@if [ "$(REV)" = "" ]; then echo "Usage: make bump-version-$* REV=<ref>"; exit 1; fi
python versions.py set-rev $* $(REV)
@if [ "$(COMMIT)" = "1" ]; then echo "[acceptance-tests] Bump $* to pick up $(REV)." | git commit -F - $(CONFIG); fi
__bump-branch-%:
@if [ "$(BRANCH)" = "" ]; then echo "Usage: make bump-branch-$* BRANCH=<branch> REMOTE_BRANCH=<remote branch>"; exit 1; fi
@if [ "$(REMOTE_BRANCH)" == "" ]; then echo "Usage: make bump-branch-$* BRANCH=<branch> REMOTE_BRANCH=<remote branch>"; exit 1; fi
python versions.py set-branch $* $(BRANCH)
python versions.py set-remote-branch $* $(REMOTE_BRANCH)
@if [ "$(COMMIT)" = "1" ]; then echo "[acceptance-tests] Bump $* to switch to $(BRANCH) $(REMOTE BRANCH)." | git commit -F - $(CONFIG); fi
__bump-current-version-%:
REV=$(shell cd $(ACCEPTANCE_TESTS_PATH)/$* && git log -1 --pretty=format:%H); \
python versions.py set-rev $* $$REV; \
if [ "$(COMMIT)" = "1" ]; then echo "[acceptance-tests] Bump $* to pick up $$REV:" | git commit -F - $(CONFIG); fi
# Bump the given submodule to the revision given by the REV make variable
# If COMMIT is 1, commit the change
bump-roslyn: __bump-version-roslyn
+4 -1
View File
@@ -160,8 +160,11 @@ if test -d $srcdir/eglib; then
echo Done running eglib/autogen.sh ...
fi
if test x$MONO_EXTRA_CONFIGURE_FLAGS != x; then
echo "MONO_EXTRA_CONFIGURE_FLAGS is $MONO_EXTRA_CONFIGURE_FLAGS"
fi
conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
conf_flags="$MONO_EXTRA_CONFIGURE_FLAGS --enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
if test x$NOCONFIGURE = x; then
echo Running $srcdir/configure $conf_flags "$@" ...
+7
View File
@@ -0,0 +1,7 @@
@echo off
cd mcs\jay
vcbuild jay.vcxproj
cd msvc\scripts
csc prepare.cs
prepare.exe ..\..\mcs core
msbuild net_4_x.sln
Executable
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
(cd mcs/jay; make)
(cd msvc/scripts/; make prepare.exe; mono prepare.exe ../../mcs core)
msbuild net_4_x.sln
+291 -152
View File
@@ -1,7 +1,8 @@
# Process this file with autoconf to produce a configure script.
#AC_PREREQ([2.62])
AC_INIT(mono, [4.5.1],
# when bumping version number below, keep it in sync with man/mono.1 too
AC_INIT(mono, [4.5.2],
[http://bugzilla.xamarin.com/enter_bug.cgi?classification=Mono])
AC_CONFIG_SRCDIR([README.md])
@@ -726,6 +727,178 @@ AC_ARG_ENABLE(system-aot, [ --enable-system-aot Enable the Ahead-Of-Time compi
DISABLED_FEATURES=none
#
# Set the build profiles and options before things which use them
#
AC_ARG_WITH(profile4_x, [ --with-profile4=yes,no If you want to install the 4.x FX (defaults to yes)], [], [with_profile4_x=default])
AC_ARG_WITH(monodroid, [ --with-monodroid=yes,no If you want to build the MonoDroid assemblies (defaults to no)], [], [with_monodroid=default])
AC_ARG_WITH(monotouch, [ --with-monotouch=yes,no If you want to build the Xamarin.iOS assemblies (defaults to no)], [], [with_monotouch=default])
AC_ARG_WITH(monotouch_watch, [ --with-monotouch_watch=yes,no If you want to build the Xamarin.WatchOS assemblies (defaults to no)],[], [with_monotouch_watch=default])
AC_ARG_WITH(monotouch_tv, [ --with-monotouch_tv=yes,no If you want to build the Xamarin.TVOS assemblies (defaults to no)], [], [with_monotouch_tv=default])
AC_ARG_WITH(bitcode, [ --with-bitcode=yes,no If bitcode is enabled (defaults to no)], [], [with_bitcode=default])
AC_ARG_WITH(xammac, [ --with-xammac=yes,no If you want to build the Xamarin.Mac assemblies (defaults to no)], [], [with_xammac=default])
AC_ARG_WITH(mobile_static, [ --with-mobile_static=yes,no If you want to build the mobile_static assemblies (defaults to no)], [], [with_mobile_static=default])
AC_ARG_WITH(runtime_preset, [ --with-runtime_preset=net_4_x,all,mobile_static,bitcode_mobile_static Which default profile to build (defaults to net_4_x)], [], [with_runtime_preset=net_4_x])
dnl
dnl Profile defaults
dnl
TEST_PROFILE=default
enable_llvm_default=no
if test x$cross_compiling = xyes -o x$enable_mcs_build = xno; then
DISABLE_MCS_DOCS_default=yes
with_profile4_x_default=no
with_monodroid_default=no
with_monotouch_default=no
with_monotouch_watch_default=no
with_monotouch_tv_default=no
with_xammac_default=no
with_mobile_static_default=no
with_bitcode_default=no
with_cooperative_gc_default=no
elif test x$with_runtime_preset = xnet_4_x; then
with_cooperative_gc_default=no
with_profile4_x_default=yes
with_monodroid_default=no
with_monotouch_default=no
with_monotouch_watch_default=no
with_monotouch_tv_default=no
with_xammac_default=no
with_mobile_static_default=no
with_bitcode_default=no
elif test x$with_runtime_preset = xall; then
with_cooperative_gc_default=no
with_profile4_x_default=yes
with_monodroid_default=yes
with_monotouch_default=yes
with_monotouch_watch_default=yes
with_monotouch_tv_default=yes
with_xammac_default=yes
with_mobile_static_default=yes
with_bitcode_default=no
elif test x$with_runtime_preset = xmobile_static; then
DISABLE_MCS_DOCS_default=yes
with_cooperative_gc_default=no
with_profile4_x_default=no
with_monodroid_default=no
with_monotouch_default=no
with_monotouch_watch_default=no
with_monotouch_tv_default=no
with_xammac_default=no
with_mobile_static_default=yes
with_bitcode_default=no
with_cooperative_gc_default=no
TEST_PROFILE=mobile_static
elif test x$with_runtime_preset = xbitcode_mobile_static; then
DISABLE_MCS_DOCS_default=yes
with_profile4_x_default=no
with_monodroid_default=no
with_monotouch_default=no
with_monotouch_watch_default=no
with_monotouch_tv_default=no
with_xammac_default=no
with_mobile_static_default=yes
with_bitcode_default=yes
with_cooperative_gc_default=yes
TEST_PROFILE=mobile_static
enable_llvm_default=yes
MONO_LLVMONLY=yes
else
with_profile4_x_default=yes
with_monodroid_default=no
with_monotouch_default=no
with_monotouch_watch_default=no
with_monotouch_tv_default=no
with_bitcode_default=no
with_xammac_default=no
with_mobile_static_default=no
with_cooperative_gc_default=no
fi
AC_SUBST(TEST_PROFILE)
if test "x$with_profile4_x" = "xdefault"; then
with_profile4_x=$with_profile4_x_default
fi
if test "x$with_monodroid" = "xdefault"; then
with_monodroid=$with_monodroid_default
fi
if test "x$with_monotouch" = "xdefault"; then
with_monotouch=$with_monotouch_default
fi
if test "x$with_monotouch_watch" = "xdefault"; then
with_monotouch_watch=$with_monotouch_watch_default
fi
if test "x$with_monotouch_tv" = "xdefault"; then
with_monotouch_tv=$with_monotouch_tv_default
fi
if test "x$with_bitcode" = "xdefault"; then
with_bitcode=$with_bitcode_default
fi
if test "x$with_xammac" = "xdefault"; then
with_xammac=$with_xammac_default
fi
if test "x$with_mobile_static" = "xdefault"; then
with_mobile_static=$with_mobile_static_default
fi
AM_CONDITIONAL(INSTALL_4_x, [test "x$with_profile4_x" = "xyes"])
AM_CONDITIONAL(INSTALL_MONODROID, [test "x$with_monodroid" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH, [test "x$with_monotouch" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH_WATCH, [test "x$with_monotouch_watch" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH_TV, [test "x$with_monotouch_tv" != "xno"])
AM_CONDITIONAL(BITCODE, test "x$with_bitcode" = "xyes")
AM_CONDITIONAL(INSTALL_XAMMAC, [test "x$with_xammac" != "xno"])
AM_CONDITIONAL(INSTALL_MOBILE_STATIC, [test "x$with_mobile_static" != "xno"])
AC_SUBST(MONO_LLVMONLY)
AC_SUBST(BITCODE)
default_profile=net_4_x
if test -z "$INSTALL_MONODROID_TRUE"; then :
default_profile=monodroid
fi
if test -z "$INSTALL_MONOTOUCH_TRUE"; then :
default_profile=monotouch
fi
if test -z "$INSTALL_XAMMAC_TRUE"; then :
default_profile=xammac
fi
if test -z "$INSTALL_MOBILE_STATIC_TRUE"; then :
default_profile=mobile_static
fi
if test -z "$INSTALL_4_x_TRUE"; then :
default_profile=net_4_x
fi
DEFAULT_PROFILE=$default_profile
AC_SUBST(DEFAULT_PROFILE)
#
# End build profile configuration
#
if test x$USE_NLS = xprofile_default; then
if test x$host_darwin = xyes; then
# We make the default value for USE_NLS
# "no" on OSX because it isn't available on most
# default OSX installs. The most common configurations will
# all disable it, so this saves us typing.
USE_NLS=no
AC_SUBST([USE_NLS])
AC_MSG_RESULT([$USE_NLS])
else
USE_NLS=yes
AC_SUBST([USE_NLS])
AC_MSG_RESULT([$USE_NLS])
fi
fi
AC_ARG_ENABLE(minimal, [ --enable-minimal=LIST drop support for LIST subsystems.
LIST is a comma-separated list from: aot, profiler, decimal, pinvoke, debug, appdomains, verifier,
reflection_emit, reflection_emit_save, large_code, logging, com, ssa, generics, attach, jit, simd, soft_debug, perfcounters, normalization, assembly_remapping, shared_perfcounters, remoting,
@@ -967,72 +1140,76 @@ AC_ARG_WITH(libgc, [ --with-gc=included,none Controls the Boehm GC config, d
AC_ARG_ENABLE(boehm, [ --disable-boehm Disable the Boehm GC.], support_boehm=$enableval,support_boehm=${support_boehm:-yes})
AM_CONDITIONAL(SUPPORT_BOEHM, test x$support_boehm = xyes)
AC_ARG_ENABLE(parallel-mark, [ --enable-parallel-mark Enables Boehm GC Parallel Marking], enable_parallel_mark=$enableval, enable_parallel_mark=$parallel_mark)
if test x$enable_parallel_mark = xyes; then
libgc_configure_args="$libgc_configure_args --enable-parallel-mark"
if test "x$support_boehm" = "xyes"; then
AC_ARG_ENABLE(parallel-mark, [ --enable-parallel-mark Enables Boehm GC Parallel Marking], enable_parallel_mark=$enableval, enable_parallel_mark=$parallel_mark)
if test x$enable_parallel_mark = xyes; then
libgc_configure_args="$libgc_configure_args --enable-parallel-mark"
fi
gc_msg=""
LIBGC_CPPFLAGS=
LIBGC_LIBS=
LIBGC_STATIC_LIBS=
libgc_dir=
case "x$libgc" in
xincluded)
if test "x$support_boehm" = "xyes"; then
libgc_dir=libgc
fi
LIBGC_CPPFLAGS='-I$(top_srcdir)/libgc/include'
LIBGC_LIBS='$(top_builddir)/libgc/libmonogc.la'
LIBGC_STATIC_LIBS='$(top_builddir)/libgc/libmonogc-static.la'
BOEHM_DEFINES="-DHAVE_BOEHM_GC"
if test x$target_win32 = xyes; then
BOEHM_DEFINES="$BOEHM_DEFINES -DGC_NOT_DLL"
CFLAGS_FOR_LIBGC="$CFLAGS_FOR_LIBGC -DGC_BUILD -DGC_NOT_DLL"
fi
gc_msg="Included Boehm GC with typed GC"
if test x$enable_parallel_mark = xyes; then
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "Included Boehm (with typed GC and Parallel Mark)", [GC description])
gc_msg="$gc_msg and parallel mark"
else
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "Included Boehm (with typed GC)", [GC description])
fi
;;
xboehm|xbohem|xyes)
AC_MSG_WARN("External Boehm is no longer supported")
;;
xsgen)
AC_MSG_WARN("Use --with-sgen instead, --with-gc= controls Boehm configuration")
;;
xnone)
AC_MSG_WARN("Compiling mono without GC.")
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "none", [GC description])
AC_DEFINE(HAVE_NULL_GC,1,[No GC support.])
gc_msg="none"
;;
*)
AC_MSG_ERROR([Invalid argument to --with-gc.])
;;
esac
AC_ARG_WITH(large-heap, [ --with-large-heap=yes,no Enable support for GC heaps larger than 3GB (defaults to no)], [large_heap=$withval], [large_heap=no])
if test "x$large_heap" = "xyes"; then
CPPFLAGS="$CPPFLAGS -DLARGE_CONFIG"
fi
AC_SUBST(LIBGC_CPPFLAGS)
AC_SUBST(LIBGC_LIBS)
AC_SUBST(LIBGC_STATIC_LIBS)
AC_SUBST(libgc_dir)
AC_SUBST(BOEHM_DEFINES)
fi
gc_msg=""
LIBGC_CPPFLAGS=
LIBGC_LIBS=
LIBGC_STATIC_LIBS=
libgc_dir=
case "x$libgc" in
xincluded)
if test "x$support_boehm" = "xyes"; then
libgc_dir=libgc
fi
LIBGC_CPPFLAGS='-I$(top_srcdir)/libgc/include'
LIBGC_LIBS='$(top_builddir)/libgc/libmonogc.la'
LIBGC_STATIC_LIBS='$(top_builddir)/libgc/libmonogc-static.la'
BOEHM_DEFINES="-DHAVE_BOEHM_GC"
if test x$target_win32 = xyes; then
BOEHM_DEFINES="$BOEHM_DEFINES -DGC_NOT_DLL"
CFLAGS_FOR_LIBGC="$CFLAGS_FOR_LIBGC -DGC_BUILD -DGC_NOT_DLL"
fi
gc_msg="Included Boehm GC with typed GC"
if test x$enable_parallel_mark = xyes; then
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "Included Boehm (with typed GC and Parallel Mark)", [GC description])
gc_msg="$gc_msg and parallel mark"
else
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "Included Boehm (with typed GC)", [GC description])
fi
;;
xboehm|xbohem|xyes)
AC_MSG_WARN("External Boehm is no longer supported")
;;
xsgen)
AC_MSG_WARN("Use --with-sgen instead, --with-gc= controls Boehm configuration")
;;
xnone)
AC_MSG_WARN("Compiling mono without GC.")
AC_DEFINE_UNQUOTED(DEFAULT_GC_NAME, "none", [GC description])
AC_DEFINE(HAVE_NULL_GC,1,[No GC support.])
gc_msg="none"
;;
*)
AC_MSG_ERROR([Invalid argument to --with-gc.])
;;
esac
AC_ARG_WITH(large-heap, [ --with-large-heap=yes,no Enable support for GC heaps larger than 3GB (defaults to no)], [large_heap=$withval], [large_heap=no])
if test "x$large_heap" = "xyes"; then
CPPFLAGS="$CPPFLAGS -DLARGE_CONFIG"
fi
AC_SUBST(LIBGC_CPPFLAGS)
AC_SUBST(LIBGC_LIBS)
AC_SUBST(LIBGC_STATIC_LIBS)
AC_SUBST(libgc_dir)
AC_SUBST(BOEHM_DEFINES)
dnl
dnl End of Boehm GC Configuration
dnl
@@ -2549,9 +2726,6 @@ if test "x$enable_nacl_codegen" = "xyes"; then
MONO_NACL_ALIGN_MASK_OFF=1
AC_DEFINE(TARGET_NACL, 1, [...])
AC_DEFINE(__native_client_codegen__, 1, [...])
else
MONO_NACL_ALIGN_MASK_OFF=0
AC_DEFINE(__default_codegen__, 1, [...])
fi
if test "x$enable_nacl_gc" = "xyes"; then
if test "x$TARGET" = "xAMD64" -o "x$TARGET" = "xX86"; then
@@ -2575,13 +2749,17 @@ dnl **************
dnl *** LLVM ***
dnl **************
AC_ARG_ENABLE(llvm,[ --enable-llvm Enable the LLVM back-end], enable_llvm=$enableval, enable_llvm=no)
AC_ARG_ENABLE(llvm,[ --enable-llvm Enable the LLVM back-end], enable_llvm=$enableval, enable_llvm=default)
AC_ARG_ENABLE(loadedllvm,[ --enable-loadedllvm Load the LLVM back-end dynamically], enable_llvm=$enableval && enable_loadedllvm=$enableval, enable_loadedllvm=no)
AC_ARG_ENABLE(llvm-version-check,[ --enable-llvm-version-check Check that the LLVM matches the version expected by mono], enable_llvm_version_check=$enableval, enable_llvm_version_check=no)
AC_ARG_ENABLE(llvm-runtime,[ --enable-llvm-runtime Enable runtime support for llvmonly code], enable_llvm_runtime=$enableval, enable_llvm_runtime=no)
AC_ARG_WITH(llvm, [ --with-llvm=<llvm prefix> Enable the LLVM back-end], enable_llvm=yes,)
if test "x$enable_llvm" = "xdefault"; then
enable_llvm=$enable_llvm_default
fi
if test "x$enable_llvm" = "xyes"; then
if test "x$with_llvm" != "x"; then
LLVM_CONFIG=$with_llvm/bin/llvm-config
@@ -2873,6 +3051,7 @@ case "$host" in
TARGET=ARM;
TARGET_SYS=WATCHOS
arch_target=arm;
arm_fpu=VFP_HARD
ACCESS_UNALIGNED="no"
CPPFLAGS="$CPPFLAGS -D__ARM_EABI__"
;;
@@ -2908,6 +3087,7 @@ case "$host" in
TARGET=ARM64
arch_target=arm64
boehm_supported=false
AOT_SUPPORTED="yes"
;;
s390x-*-linux*)
TARGET=S390X;
@@ -2933,6 +3113,7 @@ if test "x$host" != "x$target"; then
with_tls=pthread
case "$target" in
armv7k-*)
arm_fpu=VFP_HARD
AC_DEFINE(TARGET_WATCHOS, 1, [...])
;;
esac
@@ -3257,11 +3438,23 @@ dnl
dnl Simple Generational checks (sgen)
dnl
SGEN_DEFINES=
AC_ARG_WITH(sgen, [ --with-sgen=yes,no Extra Generational GC, default=yes],[buildsgen=$with_sgen],[buildsgen=yes])
AC_ARG_WITH(sgen, [ --with-sgen=yes,no Extra Generational GC, default=yes],[buildsgen=$with_sgen],[buildsgen=yes])
AC_ARG_WITH(sgen-default-concurrent, [ --with-sgen-default-concurrent=yes,no Use Concurrent GC, default=no],[],[with_sgen_default_concurrent=no])
if test x$buildsgen = xyes; then
AC_DEFINE(HAVE_MOVING_COLLECTOR, 1, [Moving collector])
SGEN_DEFINES="-DHAVE_SGEN_GC"
gc_msg="sgen and $gc_msg"
conc_gc_msg=""
if test x$with_sgen_default_concurrent != xno; then
AC_DEFINE(HAVE_CONC_GC_AS_DEFAULT, 1, [Defaults to concurrent GC])
conc_gc_msg=" (concurrent by default)"
fi
if test "x$gc_msg" = "x"; then
gc_msg="sgen$conc_gc_msg"
else
gc_msg="sgen$conc_gc_msg and $gc_msg"
fi
fi
AC_SUBST(SGEN_DEFINES)
AM_CONDITIONAL(SUPPORT_SGEN, test x$buildsgen = xyes)
@@ -3447,6 +3640,10 @@ if test ${TARGET} = ARM; then
])
fi
if test x$arm_fpu != x; then
fpu=$arm_fpu
fi
AC_MSG_RESULT($fpu)
CPPFLAGS="$CPPFLAGS -DARM_FPU_$fpu=1"
unset fpu
@@ -3510,12 +3707,6 @@ if test ${TARGET} = ARM; then
fi
fi
if test ${TARGET} = ARM; then
if test "x${with_jumptables}" = "xyes"; then
AC_DEFINE(USE_JUMP_TABLES, 1, Use jump tables in JIT)
fi
fi
if test ${TARGET} = unknown; then
CPPFLAGS="$CPPFLAGS -DNO_PORT"
AC_MSG_WARN("mono has not been ported to $host: some things may not work.")
@@ -3549,29 +3740,6 @@ case "x$libgc" in
;;
esac
AC_ARG_WITH(profile4_x, [ --with-profile4=yes,no If you want to install the 4.6 FX (defaults to yes)], [], [with_profile4_x=yes])
AC_ARG_WITH(monodroid, [ --with-monodroid=yes,no If you want to build the MonoDroid assemblies (defaults to no)], [], [with_monodroid=no])
AC_ARG_WITH(monotouch, [ --with-monotouch=yes,no If you want to build the Xamarin.iOS assemblies (defaults to no)], [], [with_monotouch=no])
AC_ARG_WITH(monotouch_watch, [ --with-monotouch_watch=yes,no If you want to build the Xamarin.WatchOS assemblies (defaults to no)],[], [with_monotouch_watch=no])
AC_ARG_WITH(monotouch_tv, [ --with-monotouch_tv=yes,no If you want to build the Xamarin.TVOS assemblies (defaults to no)], [], [with_monotouch_tv=no])
AC_ARG_WITH(bitcode, [ --with-bitcode=yes,no If bitcode is enabled (defaults to no)], [], [with_bitcode=no])
AC_ARG_WITH(xammac, [ --with-xammac=yes,no If you want to build the Xamarin.Mac assemblies (defaults to no)], [], [with_xammac=no])
AC_ARG_WITH(mobile_static, [ --with-mobile_static=yes,no If you want to build the mobile_static assemblies (defaults to no)], [], [with_mobile_static=no])
OPROFILE=no
AC_ARG_WITH(oprofile,[ --with-oprofile=no,<oprofile install dir> Enable oprofile support (defaults to no)],[
if test x$with_oprofile != xno; then
oprofile_include=$with_oprofile/include
if test ! -f $oprofile_include/opagent.h; then
AC_MSG_ERROR([oprofile include file not found at $oprofile_include/opagent.h])
fi
OPROFILE=yes
OPROFILE_CFLAGS="-I$oprofile_include"
OPROFILE_LIBS="-L$with_oprofile/lib/oprofile -lopagent"
AC_DEFINE(HAVE_OPROFILE,1,[Have oprofile support])
fi
])
MALLOC_MEMPOOLS=no
AC_ARG_WITH(malloc_mempools,[ --with-malloc-mempools=yes,no Use malloc for each single mempool allocation (only for runtime debugging, defaults to no)],[
if test x$with_malloc_mempools = xyes; then
@@ -3581,15 +3749,18 @@ AC_ARG_WITH(malloc_mempools,[ --with-malloc-mempools=yes,no Use malloc for eac
])
DISABLE_MCS_DOCS=no
DISABLE_MCS_DOCS=default
AC_ARG_WITH(mcs_docs,[ --with-mcs-docs=yes,no If you want to build the documentation under mcs (defaults to yes)],[
if test x$with_mcs_docs != xyes; then
DISABLE_MCS_DOCS=yes
fi
])
if test x$with_profile4_x != xyes; then
if test -n "$INSTALL_4_x_TRUE"; then :
DISABLE_MCS_DOCS=yes
fi
if test "x$DISABLE_MCS_DOCS" = "xdefault"; then
DISABLE_MCS_DOCS=$DISABLE_MCS_DOCS_default
fi
AC_ARG_WITH(lazy_gc_thread_creation, [ --with-lazy-gc-thread-creation=yes|no Enable lazy runtime thread creation, embedding host must do it explicitly (defaults to no)],[
if test x$with_lazy_gc_thread_creation != xno ; then
@@ -3597,11 +3768,17 @@ AC_ARG_WITH(lazy_gc_thread_creation, [ --with-lazy-gc-thread-creation=yes|no
fi
], [with_lazy_gc_thread_creation=no])
AC_ARG_WITH(cooperative_gc, [ --with-cooperative-gc=yes|no Enable cooperative stop-the-world garbage collection (sgen only) (defaults to no)],[
if test x$with_cooperative_gc != xno ; then
AC_DEFINE(USE_COOP_GC,1,[Enable cooperative stop-the-world garbage collection.])
fi
], [with_cooperative_gc=no])
AC_ARG_WITH(cooperative_gc, [ --with-cooperative-gc=yes|no Enable cooperative stop-the-world garbage collection (sgen only) (defaults to no)], [], [with_cooperative_gc=default])
if test x$with_cooperative_gc = xdefault; then
with_cooperative_gc=$with_cooperative_gc_default
fi
if test x$with_cooperative_gc != xno; then
AC_DEFINE(USE_COOP_GC,1,[Enable cooperative stop-the-world garbage collection.])
fi
AM_CONDITIONAL([ENABLE_COOP], [test x$with_cooperative_gc != xno])
AC_ARG_ENABLE(checked_build, [ --enable-checked-build=LIST To enable checked build (expensive asserts), configure with a comma-separated LIST of checked build modules and then include that same list in the environment variable MONO_CHECK_MODE at runtime. Recognized checked build modules: all, gc, metadata, thread],[
@@ -3657,20 +3834,6 @@ else
fi
AC_SUBST(LIBMONO_LA)
dnl
dnl Consistency settings
dnl
if test x$cross_compiling = xyes -o x$enable_mcs_build = xno; then
DISABLE_MCS_DOCS=yes
with_profile4_x=no
with_monodroid=no
with_monotouch=no
with_monotouch_watch=no
with_monotouch_tv=no
with_xammac=no
with_mobile_static=no
fi
if test x$DISABLE_MCS_DOCS = xyes; then
docs_dir=""
else
@@ -3681,21 +3844,8 @@ AC_SUBST(docs_dir)
## Maybe should also disable if mcsdir is invalid. Let's punt the issue for now.
AM_CONDITIONAL(BUILD_MCS, [test x$cross_compiling = xno && test x$enable_mcs_build != xno])
AM_CONDITIONAL(HAVE_OPROFILE, test x$OPROFILE = xyes)
AC_SUBST(OPROFILE_CFLAGS)
AC_SUBST(OPROFILE_LIBS)
libmono_ldflags="$libmono_ldflags $LIBS"
AM_CONDITIONAL(INSTALL_4_x, [test "x$with_profile4_x" = xyes])
AM_CONDITIONAL(INSTALL_MONODROID, [test "x$with_monodroid" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH, [test "x$with_monotouch" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH_WATCH, [test "x$with_monotouch_watch" != "xno"])
AM_CONDITIONAL(INSTALL_MONOTOUCH_TV, [test "x$with_monotouch_tv" != "xno"])
AM_CONDITIONAL(BITCODE, test "x$with_bitcode" = "xyes")
AM_CONDITIONAL(INSTALL_XAMMAC, [test "x$with_xammac" != "xno"])
AM_CONDITIONAL(INSTALL_MOBILE_STATIC, [test "x$with_mobile_static" != "xno"])
AM_CONDITIONAL(MIPS_GCC, test ${TARGET}${ac_cv_prog_gcc} = MIPSyes)
AM_CONDITIONAL(MIPS_SGI, test ${TARGET}${ac_cv_prog_gcc} = MIPSno)
AM_CONDITIONAL(SPARC, test x$TARGET = xSPARC)
@@ -3750,22 +3900,6 @@ else
fi
AC_SUBST(mono_cfg_dir)
default_profile=net_4_x
if test -z "$INSTALL_MONODROID_TRUE"; then :
default_profile=monodroid
fi
if test -z "$INSTALL_MONOTOUCH_TRUE"; then :
default_profile=monotouch
fi
if test -z "$INSTALL_XAMMAC_TRUE"; then :
default_profile=xammac
fi
if test -z "$INSTALL_4_x_TRUE"; then :
default_profile=net_4_x
fi
DEFAULT_PROFILE=$default_profile
AC_SUBST(DEFAULT_PROFILE)
AC_CONFIG_FILES([po/mcs/Makefile.in])
AC_CONFIG_FILES([runtime/mono-wrapper],[chmod +x runtime/mono-wrapper])
@@ -3932,6 +4066,7 @@ AC_OUTPUT([
Makefile
mono-uninstalled.pc
acceptance-tests/Makefile
llvm/Makefile
scripts/mono-find-provides
scripts/mono-find-requires
mono/Makefile
@@ -3998,6 +4133,7 @@ tools/Makefile
tools/locale-builder/Makefile
tools/sgen/Makefile
tools/monograph/Makefile
tools/pedump/Makefile
runtime/Makefile
msvc/Makefile
po/Makefile
@@ -4090,6 +4226,10 @@ fi
echo "BCL_OPTIMIZE = 1" >> $srcdir/$mcsdir/build/config.make
fi
if test "x$MONO_LLVMONLY" = "xyes" ; then
echo "MONO_LLVMONLY = 1" >> $srcdir/$mcsdir/build/config.make
fi
fi
)
@@ -4106,13 +4246,12 @@ echo "
TLS: $with_tls
SIGALTSTACK: $with_sigaltstack
Engine: $jit_status
oprofile: $OPROFILE
BigArrays: $enable_big_arrays
DTrace: $enable_dtrace
LLVM Back End: $enable_llvm (dynamically loaded: $enable_loadedllvm)
Libraries:
.NET 4.6: $with_profile4_x
.NET 4.x: $with_profile4_x
Xamarin.Android: $with_monodroid
Xamarin.iOS: $with_monotouch
Xamarin.WatchOS: $with_monotouch_watch
+1 -13
View File
@@ -181,7 +181,7 @@ if test "x$have_iso_varargs" = "xyes"; then
fi
AC_SUBST(G_HAVE_ISO_VARARGS)
AC_CHECK_HEADERS(getopt.h sys/select.h sys/time.h sys/wait.h pwd.h langinfo.h iconv.h localcharset.h sys/types.h sys/resource.h)
AC_CHECK_HEADERS(getopt.h sys/select.h sys/time.h sys/wait.h pwd.h iconv.h localcharset.h sys/types.h sys/resource.h)
AC_CHECK_LIB([iconv], [locale_charset],[],[AC_CHECK_LIB([charset], [locale_charset],[LIBS+="-liconv -lcharset"])])
AC_CHECK_HEADER(alloca.h, [HAVE_ALLOCA_H=1], [HAVE_ALLOCA_H=0])
AC_SUBST(HAVE_ALLOCA_H)
@@ -193,10 +193,6 @@ if test $ac_cv_sizeof_void_p = $ac_cv_sizeof_int; then
GUINT_TO_POINTER="((gpointer) (v))"
GSIZE="int"
GSIZE_FORMAT='"u"'
G_GUINT64_FORMAT='"llu"'
G_GINT64_FORMAT='"lld"'
G_GUINT32_FORMAT='"lu"'
G_GINT32_FORMAT='"ld"'
elif test $ac_cv_sizeof_void_p = $ac_cv_sizeof_long; then
GPOINTER_TO_INT="((gint)(long) (ptr))"
GPOINTER_TO_UINT="((guint)(long) (ptr))"
@@ -204,10 +200,6 @@ elif test $ac_cv_sizeof_void_p = $ac_cv_sizeof_long; then
GUINT_TO_POINTER="((gpointer)(gulong) (v))"
GSIZE="long"
GSIZE_FORMAT='"lu"'
G_GUINT64_FORMAT='"lu"'
G_GINT64_FORMAT='"ld"'
G_GUINT32_FORMAT='"u"'
G_GINT32_FORMAT='"d"'
elif test $ac_cv_sizeof_void_p = $ac_cv_sizeof_long_long; then
GPOINTER_TO_INT="((gint)(long long) (ptr))"
GPOINTER_TO_UINT="((guint)(unsigned long long) (ptr))"
@@ -215,10 +207,6 @@ elif test $ac_cv_sizeof_void_p = $ac_cv_sizeof_long_long; then
GUINT_TO_POINTER="((gpointer)(unsigned long long) (v))"
GSIZE="long long"
GSIZE_FORMAT='"I64u"'
G_GUINT64_FORMAT='"I64u"'
G_GINT64_FORMAT='"I64i"'
G_GUINT32_FORMAT='"I32u"'
G_GINT32_FORMAT='"I32i"'
else
AC_MSG_ERROR([unsupported pointer size])
fi
-4
View File
@@ -27,10 +27,6 @@ typedef unsigned @GSIZE@ gsize;
typedef signed @GSIZE@ gssize;
#define G_GSIZE_FORMAT @GSIZE_FORMAT@
#define G_GUINT64_FORMAT @G_GUINT64_FORMAT@
#define G_GINT64_FORMAT @G_GINT64_FORMAT@
#define G_GUINT32_FORMAT @G_GUINT32_FORMAT@
#define G_GINT32_FORMAT @G_GINT32_FORMAT@
#if @G_HAVE_ISO_VARARGS@ == 1
#define G_HAVE_ISO_VARARGS
-13
View File
@@ -26,27 +26,14 @@ typedef int pid_t;
#define G_SEARCHPATH_SEPARATOR_S ";"
#define G_SEARCHPATH_SEPARATOR ';'
#define G_GSIZE_FORMAT "d"
#define G_GUINT64_FORMAT "d"
#define G_GINT64_FORMAT "d"
#define GPOINTER_TO_INT(ptr) ((gint)(intptr_t) (ptr))
#define GPOINTER_TO_UINT(ptr) ((guint)(intptr_t) (ptr))
#define GINT_TO_POINTER(v) ((gpointer)(intptr_t) (v))
#define GUINT_TO_POINTER(v) ((gpointer)(intptr_t) (v))
/* VS 2010 and later have stdint.h */
#if defined(_MSC_VER) && _MSC_VER < 1600
#define INT32_MAX 2147483647
#define INT32_MIN (~ INT32_MAX)
#define INT64_MAX 9223372036854775807i64
#define INT64_MIN (~INT64_MAX)
#define UINT32_MAX 0xffffffffU
#define UINT64_MAX 0xffffffffffffffffULL
#endif
#define STDOUT_FILENO (int)(intptr_t)stdout
#define STDERR_FILENO (int)(intptr_t)stderr
/* FIXME: what should this be ?*/
#define X_OK 4 /* This is really read */
#define WNOHANG 1
+5 -21
View File
@@ -13,11 +13,7 @@
#pragma include_alias(<eglib-config.h>, <eglib-config.hw>)
#endif
/* VS 2010 and later have stdint.h */
#if defined(_MSC_VER) && _MSC_VER < 1600
#else
#include <stdint.h>
#endif
#include <eglib-config.h>
#ifndef EGLIB_NO_REMAP
@@ -63,21 +59,6 @@ typedef const void * gconstpointer;
typedef char gchar;
typedef unsigned char guchar;
#if !G_TYPES_DEFINED
/* VS 2010 and later have stdint.h */
#if defined(_MSC_VER) && _MSC_VER < 1600
typedef __int8 gint8;
typedef unsigned __int8 guint8;
typedef __int16 gint16;
typedef unsigned __int16 guint16;
typedef __int32 gint32;
typedef unsigned __int32 guint32;
typedef __int64 gint64;
typedef unsigned __int64 guint64;
typedef float gfloat;
typedef double gdouble;
typedef int gboolean;
#else
/* Types defined in terms of the stdint.h */
typedef int8_t gint8;
typedef uint8_t guint8;
@@ -90,8 +71,6 @@ typedef uint64_t guint64;
typedef float gfloat;
typedef double gdouble;
typedef int32_t gboolean;
#endif
#endif
typedef guint16 gunichar2;
typedef guint32 gunichar;
@@ -135,6 +114,11 @@ typedef guint32 gunichar;
#define G_CONST_RETURN const
#define G_GUINT64_FORMAT PRIu64
#define G_GINT64_FORMAT PRIi64
#define G_GUINT32_FORMAT PRIu32
#define G_GINT32_FORMAT PRIi32
/*
* Allocation
*/
+1 -6
View File
@@ -44,9 +44,6 @@
# define CODESET 1
# include <windows.h>
#else
# ifdef HAVE_LANGINFO_H
# include <langinfo.h>
# endif
# ifdef HAVE_LOCALCHARSET_H
# include <localcharset.h>
# endif
@@ -219,9 +216,7 @@ g_get_charset (G_CONST_RETURN char **charset)
is_utf8 = FALSE;
#else
/* These shouldn't be heap allocated */
#if defined(HAVE_LANGINFO_H)
my_charset = nl_langinfo (CODESET);
#elif defined(HAVE_LOCALCHARSET_H)
#if defined(HAVE_LOCALCHARSET_H)
my_charset = locale_charset ();
#else
my_charset = "UTF-8";
+1 -1
+1 -1
View File
@@ -184,7 +184,7 @@ static GC_thread GC_new_thread(void) {
#ifdef __GNUC__
__inline__
#endif
LONG GC_get_max_thread_index()
static LONG GC_get_max_thread_index()
{
LONG my_max = GC_max_thread_index;
+2
View File
@@ -0,0 +1,2 @@
/Makefile
/Makefile.in
+29
View File
@@ -0,0 +1,29 @@
#
# Conditional submodule for llvm
#
# make reset-llvm will checkout a version of llvm which is suitable for this version of mono
# into $top_srcdir/llvm/llvm.
#
LLVM_PATH=llvm
include $(top_srcdir)/scripts/submodules/versions.mk
$(eval $(call ValidateVersionTemplate,llvm,LLVM))
# Bump the given submodule to the revision given by the REV make variable
# If COMMIT is 1, commit the change
bump-llvm: __bump-version-llvm
# Bump the given submodule to the branch given by the BRANCH/REMOTE_BRANCH make variables
# If COMMIT is 1, commit the change
bump-branch-llvm: __bump-branch-llvm
# Bump the given submodule to its current GIT version
# If COMMIT is 1, commit the change
bump-current-llvm: __bump-current-version-llvm
clean-local:
$(RM) -r $(LLVM_PATH)
EXTRA_DIST=SUBMODULES.json
+10
View File
@@ -0,0 +1,10 @@
[
{
"name": "llvm",
"url": "git://github.com/mono/llvm.git",
"rev": "9f79399f87282524fee099b328bd8cbf07929daf",
"remote-branch": "origin/master",
"branch": "master",
"directory": "llvm"
}
]
+1 -1
View File
@@ -26,7 +26,7 @@ AC_DEFUN([AM_NLS],
dnl Default is enabled NLS
AC_ARG_ENABLE([nls],
[ --disable-nls do not use Native Language Support],
USE_NLS=$enableval, USE_NLS=yes)
USE_NLS=$enableval, USE_NLS=profile_default)
AC_MSG_RESULT([$USE_NLS])
AC_SUBST([USE_NLS])
])
+56 -15
View File
@@ -21,9 +21,34 @@ default only the assemblies specified in the command line will be
included in the bundle. To automatically include all of the
dependencies referenced, use the "--deps" command line option.
.PP
Use \fImkbundle\FP when you want the startup runtime to load the 1.0
profile, and use \fImkbundle2\fP when you want the startup runtime to load
the 2.0 profile.
There are two modes of operation, the default one uses the
C compiler to create a bundle and requires a complete C and Mono SDK
to produced executables. The simple mode (enabled when using the
"--simple") command line option does not require this, and also allows
for cross compilation.
.PP
For example, to create a bundle for hello world, use the following
command:
.nf
$ mkbundle -o hello --simple hello.exe
.fi
.PP
The simple version allows for cross-compiling, this requires a Mono
runtime to be installed in the ~/.mono/targets/TARGET/mono to be
available. You can use the "--local-targets" to list all available
targets, and the "--cross" argument to specify the target, like this:
.nf
$ mkbundle --local-targets
Available targets:
default - Current System Mono
4.4.0-macosx-x86
4.4.0-debian-8-arm64
$ mkbundle --cross 4.4.0-debian-8-powerpc hello.exe -o hello-debian
.fi
.PP
The above will bundle your native library into hello-debian for
a Debian 8 system running on a PowerPC machine.
.SH OLD EMBEDDING
.PP
For example, to create a bundle for hello world, use the following
command:
@@ -57,6 +82,12 @@ are available to the embedded runtime.
.I "-c"
Produce the stub file, do not compile the resulting stub.
.TP
.I "--cross target"
Creates a bundle for the specified target platform. The target
must be a directory in ~/.mono/targets/ that contains a "mono"
binary. You can fetch various targets using the --fetch-target
command line option.
.TP
.I "-o filename"
Places the output on `out'. If the flag -c is specified, this is the
C host program. If not, this contains the resulting executable.
@@ -74,20 +105,31 @@ Typically this is $prefix/etc/mono/1.0/machine.config or
$prefix/etc/mono/2.0/machine.config depending on the profile that you
are using (1.0 or 2.0)
.TP
.I "--nodeps"
This is the default: \fImkbundle\fP will only include the assemblies that
were specified on the command line to reduce the size of the resulting
image created.
.TP
.I "--deps"
This option will bundle all of the referenced assemblies for the
assemblies listed on the command line option. This is useful to
distribute a self-contained image.
.TP
.I "--fetch-target target"
Downloads a precompiled runtime for the specified target from the Mono
distribution site.
.TP
.I "--nodeps"
This is the default: \fImkbundle\fP will only include the assemblies that
were specified on the command line to reduce the size of the resulting
image created.
.TP
.I "--keeptemp"
By default \fImkbundle\fP will delete the temporary files that it uses to
produce the bundle. This option keeps the file around.
.TP
.I "--lists-targets"
Lists all of the available local cross compilation targets available
as precompiled binaries on the Mono distribution server.
.TP
.I "--local-targets"
Lists all of the available local cross compilation targets.
.TP
.I "--machine-config FILE"
Uses the given FILE as the machine.config file for the generated
application.
@@ -102,13 +144,10 @@ When passed, DIR will be set for the MONO_CFG_DIR environment variable
By default \fImkbundle\fP dynamically links to mono and glib. This option
causes it to statically link instead.
.TP
.B Important:
Since the Mono runtime is licensed under the LGPL, even if you use
static you should transfer the component pieces of the mkbundle to
your users so they are able to upgrade the Mono runtime on their own.
.TP
If you want to use this for commercial licenses, you must obtain a
proprietary license for Mono from [email protected]
.I "--target-server SERVER"
By default the mkbundle tool will download from a Mono server the
target runtimes, you can specify a different server to provide
cross-compiled runtimes.
.TP
.I "-z"
Compresses the assemblies before embedding. This results in smaller
@@ -133,6 +172,8 @@ Mono runtime, separated by spaces. See the mono(1) manual page or run mono --hel
.SH FILES
This program will load referenced assemblies from the Mono assembly
cache.
.PP
Targets are loaded from ~/.mono/targets/TARGETNAME/mono
.SH BUGS
The option "--static" is not supported under Windows.
Moreover, a full cygwin environment containing at least "gcc" and "as"
+1 -1
View File
@@ -7,7 +7,7 @@
.\" Author:
.\" Miguel de Icaza ([email protected])
.\"
.TH Mono "Mono 3.0"
.TH Mono "Mono 4.5.2"
.SH NAME
mono \- Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-of-Time)
.SH SYNOPSIS
+9
View File
@@ -20,3 +20,12 @@ class/RabbitMQ.Client/docs/specs/autogenerated-api-qpid-0-8.cs
class/System.Web.Mvc/System.Web.Mvc/Resources/MvcResources.resources
class/System.Web.Mvc2/System.Web.Mvc/Resources/MvcResources.resources
XmlWriter
obj-net_4_x
obj-bare
obj-plainweb
obj-Facades
obj-plaincore
obj-plaindesign
obj-plainservice
obj-secxml
obj-mcs-net_4_x
+8 -2
View File
@@ -15,8 +15,6 @@ build system needs to let us do, specifically:
** Makefile structure
A general makefile looks like this:
@@ -438,7 +436,15 @@ To give it flags, set $(LOCAL_CFLAGS). As with compiling C#, the
variable $(CFLAGS) will automatically be included on the command line.
* Compiling resources with resgen
If you have a resource that should be compiled with resgen and
included in your assembly, you can use the RESOURCES_DEFS variable.
This variable can contain lists of pairs that are separated by comma
to represent the resource ID as embedded in the assembly followed by
the file name, like this:
RESOURCE_DEFS = Messages,TextResources.resx Errors,ErrorList.txt
* Documentation-related needs? Use $(MDOC)
+10
View File
@@ -154,6 +154,15 @@ MCS_REFERENCES += $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/%.exe,$(EXE_REF
all-local: $(makefrag) $(extra_targets)
ifdef BUILT_SOURCES
library_CLEAN_FILES += $(BUILT_SOURCES)
ifeq (cat, $(PLATFORM_CHANGE_SEPARATOR_CMD))
BUILT_SOURCES_cmdline = $(BUILT_SOURCES)
else
BUILT_SOURCES_cmdline = `echo $(BUILT_SOURCES) | $(PLATFORM_CHANGE_SEPARATOR_CMD)`
endif
endif
csproj-local:
config_file=`basename $(PROGRAM) .exe`-$(PROFILE).input; \
echo $(thisdir):$$config_file >> $(topdir)/../msvc/scripts/order; \
@@ -164,6 +173,7 @@ csproj-local:
echo $(build_lib); \
echo $(FRAMEWORK_VERSION); \
echo $(PROFILE); \
echo $(RESOURCE_DEFS); \
echo $(response)) > $(topdir)/../msvc/scripts/inputs/$$config_file
+28 -5
View File
@@ -134,7 +134,7 @@ endif
csproj-local: csproj-library csproj-test
intermediate_clean=$(subst /,-,$(intermediate))
csproj-library:
csproj-library:
config_file=`basename $(LIBRARY) .dll`-$(intermediate_clean)$(PROFILE).input; \
case "$(thisdir)" in *"Facades"*) config_file=Facades_$$config_file;; esac; \
echo $(thisdir):$$config_file >> $(topdir)/../msvc/scripts/order; \
@@ -145,6 +145,7 @@ csproj-library:
echo $(build_lib); \
echo $(FRAMEWORK_VERSION); \
echo $(PROFILE); \
echo $(RESOURCE_DEFS); \
echo $(response)) > $(topdir)/../msvc/scripts/inputs/$$config_file
csproj-test:
@@ -216,7 +217,28 @@ clean-local:
test-local run-test-local run-test-ondotnet-local:
@:
DISTFILES = $(wildcard *$(LIBRARY)*.sources) $(EXTRA_DISTFILES)
#
# RESOURCES_DEFS is a list of ID,FILE pairs separated by spaces
# for each of those, generate a rule that produces ID.resource from
# FILE using the resgen tool, adds the generated file to CLENA_FILES and
# passes the resource to the compiler
#
ccomma = ,
define RESOURCE_template
$(1).resources: $(2)
$(RESGEN) "$$<" "$$@"
GEN_RESOURCE_DEPS += $(1).resources
GEN_RESOURCE_FLAGS += -resource:$(1).resources
CLEAN_FILES += $(1).resources
DIST_LISTED_RESOURCES += $(2)
endef
ifdef RESOURCE_DEFS
$(foreach pair,$(RESOURCE_DEFS), $(eval $(call RESOURCE_template,$(word 1, $(subst $(ccomma), ,$(pair))), $(word 2, $(subst $(ccomma), ,$(pair))))))
endif
DISTFILES = $(wildcard *$(LIBRARY)*.sources) $(EXTRA_DISTFILES) $(DIST_LISTED_RESOURCES)
ASSEMBLY = $(LIBRARY)
ASSEMBLY_EXT = .dll
@@ -236,6 +258,7 @@ csproj-test:
echo $(test_lib); \
echo $(FRAMEWORK_VERSION); \
echo $(PROFILE); \
echo ""; \
echo $(test_response)) > $(topdir)/../msvc/scripts/inputs/$$config_file
endif
@@ -275,12 +298,12 @@ endif
$(the_lib): $(the_libdir)/.stamp
$(build_lib): $(response) $(sn) $(BUILT_SOURCES) $(build_libdir:=/.stamp)
$(LIBRARY_COMPILE) $(LIBRARY_FLAGS) $(LIB_MCS_FLAGS) -target:library -out:$@ $(BUILT_SOURCES_cmdline) @$(response)
$(Q) $(SN) -R $@ $(LIBRARY_SNK)
$(build_lib): $(response) $(sn) $(BUILT_SOURCES) $(build_libdir:=/.stamp) $(GEN_RESOURCE_DEPS)
$(LIBRARY_COMPILE) $(LIBRARY_FLAGS) $(LIB_MCS_FLAGS) $(GEN_RESOURCE_FLAGS) -target:library -out:$@ $(BUILT_SOURCES_cmdline) @$(response)
ifdef RESOURCE_STRINGS_FILES
$(Q) $(STRING_REPLACER) $(RESOURCE_STRINGS_FILES) $@
endif
$(Q) $(SN) -R $@ $(LIBRARY_SNK)
ifdef LIBRARY_USE_INTERMEDIATE_FILE
$(the_lib): $(build_lib)
+1 -1
View File
@@ -18,7 +18,7 @@ endif
MCS = $(with_mono_path) $(INTERNAL_GMCS)
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:BOOTSTRAP_BASIC -nowarn:1699 -d:DISABLE_CAS_USE -lib:$(topdir)/class/lib/$(PROFILE)
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:BOOTSTRAP_BASIC -nowarn:1699 -lib:$(topdir)/class/lib/$(PROFILE)
NO_SIGN_ASSEMBLY = yes
NO_TEST = yes
NO_INSTALL = yes
+1 -1
View File
@@ -13,7 +13,7 @@ profile-check:
@:
DEFAULT_REFERENCES = -r:$(topdir)/class/lib/$(PROFILE)/mscorlib.dll
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:DISABLE_CAS_USE -nowarn:1699 -nostdlib $(DEFAULT_REFERENCES)
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -nowarn:1699 -nostdlib $(DEFAULT_REFERENCES)
NO_SIGN_ASSEMBLY = yes
NO_TEST = yes
-1
View File
@@ -23,7 +23,6 @@ PROFILE_MCS_FLAGS = \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:DISABLE_CAS_USE \
-nowarn:1699 \
-nostdlib \
$(DEFAULT_REFERENCES) \
+1 -2
View File
@@ -21,7 +21,6 @@ PROFILE_MCS_FLAGS = \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:DISABLE_CAS_USE \
-d:MOBILE,MOBILE_STATIC,MOBILE_LEGACY \
-d:FULL_AOT_RUNTIME \
-d:DISABLE_REMOTING \
@@ -41,7 +40,7 @@ MOBILE_PROFILE = yes
NO_VTS_TEST = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
ifndef MONO_DISABLE_GSHAREDVT
GSHAREDVT_FLAG = -O=gsharedvt
-1
View File
@@ -21,7 +21,6 @@ PROFILE_MCS_FLAGS = \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:DISABLE_CAS_USE \
-d:MOBILE,MOBILE_LEGACY \
-d:MOBILE_DYNAMIC \
-d:MONODROID \
@@ -23,7 +23,6 @@ PROFILE_MCS_FLAGS = \
-d:NET_4_5 \
-d:MOBILE,MOBILE_LEGACY \
-d:MONO \
-d:DISABLE_CAS_USE \
-d:MONOTOUCH \
-d:DISABLE_REMOTING \
-d:DISABLE_COM \
+1 -1
View File
@@ -11,7 +11,7 @@ profile-check:
@:
DEFAULT_REFERENCES = -r:$(topdir)/class/lib/$(PROFILE)/mscorlib.dll
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:NET_4_6 -d:MONO -d:DISABLE_CAS_USE -nowarn:1699 -nostdlib $(DEFAULT_REFERENCES) $(PLATFORM_DEBUG_FLAGS)
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:NET_4_6 -d:MONO -nowarn:1699 -nostdlib $(DEFAULT_REFERENCES) $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
XBUILD_VERSION = 4.0
-1
View File
@@ -19,7 +19,6 @@ PROFILE_MCS_FLAGS = \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:DISABLE_CAS_USE \
-d:MOBILE \
-d:MOBILE_DYNAMIC \
-d:XAMMAC \
+3 -3
View File
@@ -144,11 +144,11 @@ endif
# Set the options for building and running AOT
# The trampoline numbers are provisional, they are what is required
# to run the corlib test suite. They should be considered a lower bound.
INVARIANT_AOT_OPTIONS=nimt-trampolines=900,ntrampolines=8000
# to run the mcs/class test suites. They should be considered a lower bound.
INVARIANT_AOT_OPTIONS=nimt-trampolines=900,ntrampolines=8000,nrgctx-fetch-trampolines=256
ifndef MONO_DISABLE_GSHAREDVT
INVARIANT_AOT_OPTIONS:=$(INVARIANT_AOT_OPTIONS),ngsharedvt-trampolines=900
INVARIANT_AOT_OPTIONS:=$(INVARIANT_AOT_OPTIONS),ngsharedvt-trampolines=2800
endif
AOT_BUILD_FLAGS = $(AOT_BUILD_FLAGS_PREFIX)$(INVARIANT_AOT_OPTIONS)
+1 -1
View File
@@ -38,7 +38,7 @@ test_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
endif
test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll)
test_sourcefile_excludes = $(test_lib).excludes
test_sourcefile_excludes = $(test_lib).exclude.sources
test_pdb = $(test_lib:.dll=.pdb)
test_response = $(depsdir)/$(test_lib).response
@@ -9,7 +9,10 @@
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<OutputPath>./../../class/lib/net_4_x</OutputPath>
<IntermediateOutputPath>obj-net_4_x</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
@@ -57,15 +60,14 @@
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
@@ -9,7 +9,10 @@
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<OutputPath>./../../class/lib/net_4_x</OutputPath>
<IntermediateOutputPath>obj-net_4_x</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
@@ -93,15 +96,16 @@
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay > $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay > $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
+7 -5
View File
@@ -9,7 +9,10 @@
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<OutputPath>./../../class/lib/net_4_x</OutputPath>
<IntermediateOutputPath>obj-net_4_x</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
@@ -60,15 +63,14 @@
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
@@ -9,7 +9,10 @@
<OutputType>Library</OutputType>
<NoWarn>1699</NoWarn>
<OutputPath>./../../class/lib/net_4_x</OutputPath>
<IntermediateOutputPath>obj-net_4_x</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
@@ -61,15 +64,14 @@
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{699E0DB5-EDD0-4E6A-87C9-D396DCDAF620}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>Microsoft.Win32.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{7B15C4D7-8C02-408E-9EFB-5E9E9FB4410D}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>Microsoft.Win32.Registry.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{160B5B14-7A25-458E-B83F-35632C832866}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>Microsoft.Win32.Registry</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B6B7A903-D696-43CF-AC42-39DCAAB00B9D}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.AppContext</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{EFD0287C-3651-4D42-B8CA-430776CB1E6D}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Collections.Concurrent</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5F686C07-72CE-4A42-93B1-52B31227C3BB}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Collections.NonGeneric</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5A238E60-587C-4C5C-8CA4-0443B1DBF1F6}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Collections.Specialized</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{2597261D-EC05-4333-928D-1CA44AB1A5D2}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Collections</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B26700A5-4A9A-4358-8C84-51AD67C706BA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.ComponentModel.Annotations</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.ComponentModel.DataAnnotations/System.ComponentModel.DataAnnotations-net_4_x.csproj">
<Project>{8F86C287-38A5-49F8-BE6D-1E0E3D74AF39}</Project>
<Name>System.ComponentModel.DataAnnotations-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{6871A822-F21C-4C0E-B97B-178FF6C3DB46}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.ComponentModel.EventBasedAsync</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{1DF9021C-DC67-4D7B-BEC9-10D7FBC12972}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.ComponentModel.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{FC19760B-00FF-4242-9760-9C8E9C87CCFB}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.ComponentModel.TypeConverter</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{3FA73846-3666-4769-B431-1A7538B08F39}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.ComponentModel</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{6207AADB-0592-4B52-B71E-3565196EE893}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Console</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{360CDD70-6108-4406-9433-7BB178B0C3E3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Data.Common</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Data/System.Data-net_4_x.csproj">
<Project>{EC439BB8-FFED-4A32-A05D-2FA3A70CAD64}</Project>
<Name>System.Data-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,102 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{575873BD-22DA-4A36-ABBD-B074EFEAB3AD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Data.SqlClient</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Data/System.Data-net_4_x.csproj">
<Project>{EC439BB8-FFED-4A32-A05D-2FA3A70CAD64}</Project>
<Name>System.Data-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.XML/System.Xml-net_4_x.csproj">
<Project>{87FD2F0F-5222-4AE6-BD63-2D4975E11E5B}</Project>
<Name>System.Xml-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,90 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{8892480E-A4C6-4C4C-8722-21C5483F8851}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.Contracts</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{7221EF5D-7340-4E8C-99F0-9EE9C55AA189}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.Debug</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{D81BCBD3-415D-4309-A116-0B475D8A2FA8}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.FileVersionInfo</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{BA0C64F1-3762-437D-8B58-75F68A5B4E7E}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.PerformanceCounter</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{BFE6F5CE-725C-4F96-8AC6-F66B7C56E972}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.Process</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{871BE2C6-2F56-4E05-93E8-9B3FDD4711DB}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.StackTrace</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{EE8443AB-125D-4055-981A-143FB827C23C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.TextWriterTraceListener</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5B299463-3E19-48C1-8625-31E12E1CC146}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.Tools</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{6460F8E8-775E-46B6-99E5-B48390591515}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.TraceEvent</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{530F1E68-3237-49E6-8D3B-06332F5AC055}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.TraceSource</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,90 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B33966AB-7211-43B4-B5C0-3F818869CB08}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Diagnostics.Tracing</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -29,6 +29,7 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventOpcode))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventSource))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventSourceAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventSourceSettings))]
//[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventSourceException))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventTask))]
//[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Diagnostics.Tracing.EventWrittenEventArgs))]
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{E48CEF36-3218-477B-A8B5-014519207FF2}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Dynamic.Runtime</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{BC71DA11-382F-459A-B3C3-F2F4267974FB}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Globalization.Calendars</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B875622B-BEA2-4D1C-8242-3A1FCECF5890}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Globalization.Extensions</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,90 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5F313CA5-F0FC-4EA3-AC8D-8EF1C7FC8ABE}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Globalization</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{A8EB5499-FA67-4049-AA0A-241D82DA975C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.Compression.ZipFile</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.IO.Compression.FileSystem/System.IO.Compression.FileSystem-net_4_x.csproj">
<Project>{9E61FF2E-493E-4CA0-BBDA-2EF96A4CB058}</Project>
<Name>System.IO.Compression.FileSystem-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{321A53F3-A681-4CA5-A093-1C6650243F6A}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.FileSystem.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{121F835D-CD32-4C19-ABA7-25EF4B84773F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.FileSystem.DriveInfo</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5DF20007-FD1D-4BD8-A492-D1C4F7CAD2BF}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.FileSystem.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{44647FAA-F785-44DE-B6B2-ABC2B9768233}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.FileSystem.Watcher</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{3CBF9A55-86B6-4E0B-A73E-E352C79D85E8}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.FileSystem</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{A9B2D389-B9E5-4B0F-8115-2AADF285D217}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.IsolatedStorage</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{18639F0F-74F1-4B61-81BF-D60B651F542A}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.MemoryMappedFiles</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,98 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{D835F3A9-C4FE-4162-8AB5-DC26D06AC81F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.Pipes</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{981E765A-9D68-4653-9079-69BFCD97F086}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO.UnmanagedMemoryStream</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{6C8B94F6-E589-472C-80CA-BD55DAFAC523}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.IO</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{24ADB02E-2E84-4EF4-BDD4-F20C87AEA6A3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Linq.Expressions</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{CFF3822F-E829-4AEF-899A-963C4EAF6941}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Linq.Parallel</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{49E80FC1-1707-4715-8D94-CBDC79B007E9}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Linq.Queryable</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{9F1C9D98-4C32-4698-B26F-10A38B5073B0}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Linq</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Core/System.Core-net_4_x.csproj">
<Project>{359142A1-D80F-401E-AA64-7167C9317649}</Project>
<Name>System.Core-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B6DBC302-E9DB-4464-979C-6D714B436A7E}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.AuthenticationManager</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{101D931B-24CE-44CE-8140-8B183D5CC46E}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Cache</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,102 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{ACA10642-1D5B-443D-99BE-65C31491C54F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Http.WebRequestHandler</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Net.Http.WebRequest/System.Net.Http.WebRequest-net_4_x.csproj">
<Project>{A98B5CC3-EAFC-4EFD-ABC6-2F2A65BE98F5}</Project>
<Name>System.Net.Http.WebRequest-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System.Net.Http/System.Net.Http-net_4_x.csproj">
<Project>{F1636C0A-FC68-4362-918F-9CCC789FED13}</Project>
<Name>System.Net.Http-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{CC7A11AC-ACAA-4707-BEF1-1106938F19C7}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.HttpListener</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{074DF29D-D38E-4FB9-86A0-18F47615CE72}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Mail</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{1219DA91-575A-45EA-9CC9-1471648A025F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.NameResolution</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B6AE3A72-1756-46BF-9105-C4D815A5C044}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.NetworkInformation</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{79BB52C8-198A-4238-B2F6-62CEEBD7D228}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{538C60BD-0652-4780-AA7C-338C2DD82448}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Requests</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{601F297E-1242-4BC4-BD06-1111CE65D658}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Security</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B0CF71F6-DCD4-4C7B-BE36-BF9CB0CB366C}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.ServicePoint</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
@@ -0,0 +1,94 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{FC7570DA-CAE1-40AF-9EB4-9C9566746023}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<OutputPath>./../../../class/lib/net_4_x/Facades</OutputPath>
<IntermediateOutputPath>obj-Facades</IntermediateOutputPath>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>
</RootNamespace>
<AssemblyName>System.Net.Sockets</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>false</Optimize>
<DefineConstants>TRACE;NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<NoWarn>1699,1616,1699</NoWarn>
<Optimize>true</Optimize>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;DISABLE_CAS_USE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />␍ </ItemGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PreBuildEvent>
<PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
</PostBuildEvent>
<PostBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">
</PostBuildEvent>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../corlib/corlib-net_4_x.csproj">
<Project>{2CA6026B-2DC8-4C4C-A12C-1E8234049DB7}</Project>
<Name>corlib-net_4_x</Name>
</ProjectReference>
<ProjectReference Include="../../System/System-net_4_x.csproj">
<Project>{2762E921-91A8-4C87-91E9-BA628013F753}</Project>
<Name>System-net_4_x</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Folder Include="Properties\" />
</ItemGroup>
</Project>
Loaded 100 of 1184 files, more files were not shown because too many files have changed in this diff. Show more