Fixes an issue in Process where "pseudo-handles" for processes with
pids > 16 bits would overflow and start getting treated as normal
handles. This would frequently segfault MonoDevelop on MacOS.
When we are not using SHM we use psuedo handles to return processes from pids,
however we dont guard against pseudo-handles in CloseProcess, which could lead to
calling unref on a fake handle.
Pass the listener as it's own async state so that we avoid potential null derefs in the callback. Also wrap the BeginAccept and EndAccept calls in their own try/catches in case they throw an exception.
Fix possible state corruption in the case where Upgradeable wasn't reactivating its read bit after a downgrade and set events accordingly. Fix possible race where a write process wannabe could step in the middle of Upgradeable actually upgrading to write mode.
Conflicts:
mcs/class/System.Core/System.Threading/ReaderWriterLockSlim.cs
The patch removes a small race condition where a boolean flag is set after acquiring a lock to
indicate to code executing in the finally {} block that it should release the lock. The boolean
variable is now removed and the lock is released unconditionally. It carries a potential to
throw an exception when the lock is not held, but it's better than to fail to release it and
lead the application to a deadlock.
* AssemblyBuilder.cs (GetTypes): Raise ReflectionTypeLoadException
if any type was not finished.
* AssemblyBuilderTest.cs: Add test for GetTypes () and incomplete
TypeBuilders'.
Fixes#640288
* threads.c (mono_thread_suspend_all_other_threads): wait_data
must not be malloc'd since it holds managed pointers. Alloc
it on stack since the struct is about 512/1024 bytes long.
* threads.c (mono_thread_manage): Ditto.
* threads.c (mono_threads_request_thread_dump): Ditto.
This error was found by Gonzalo when he was looking at another problem
when thread IDs overflowed ints.
Currently we use gpointers in the io-layer for the threadid, but we were
only exposing the value as an int32. The good news is that the code is
not really used right now, but could cause problems in the future as we
extend Process.
* Type.cs (GetTypeCodeImpl): If the type is a TypeBuilder
call into specific code.
* TypeBuilder.cs (GetTypeCodeInternal): New method that
handles enums correctly.
This change is required because calling into the runtime
with incomplete TypeBuilders cause the runtime to crash.
The embedding code looks at the executable name, and builds the embedding profile
from that, however the default install has a /usr/bin/mono symlink pointing to
/Library/Frameworks/Mono.framework. We now resolve the symlink before allowing
the embedding code to proceed.
Android defines a variable called "major" in its headers, lets rename
major -> major_collector to work around the conflict.
Not every architecture/platform has ucontext_t, so lets not strongly
type our contexts to that and let the macros do their job.
when running with SGEN, since SGEN writes to those arrays in:
==29095== at 0x6844E5: add_or_remove_disappearing_link (sgen-gc.c:4143)
==29095== by 0x6845F8: mono_gc_register_disappearing_link (sgen-gc.c:4167)
==29095== by 0x67DE35: clear_domain_process_object (sgen-gc.c:1384)
==29095== by 0x67DEA3: clear_domain_process_major_object_callback (sgen-gc.c:1400)
==29095== by 0x6DE2DC: major_iterate_objects (sgen-marksweep.c:692)
==29095== by 0x67E00B: mono_gc_clear_domain (sgen-gc.c:1459)
* debugger-agent.c: The end_runtime_invoke guard isn't working
on AMD64 as __builtin_frame_address (1) returns NULL. Disable the
behaviour by default, and make it runtime configurable.
svn path=/branches/mono-2-6/mono/; revision=148421
Simplifies the code a little bit by eliminating the in_quote variable,
but also fixes the rules to follow the requirements from the
"Shell Command Language" specification on the Unix03 site:
http://opengroup.org/onlinepubs/007908775/xcu/chap2.html#tag_001_002
In particular, the interpretation of the backslash inside double quotes
is limited to a handful of characters. Notice that this differs from
the glib implementation which is not correct either.
If we are redirecting to a GET from a POST, the Content-Length header
might have stale data and it will be sent. Some servers, instead of
ignoring it, keep waiting for the data to be sent (for a GET!).
Fixes bug #636219.
We were usign teh URL, but that might not be unique among several
requests that need to be authenticated using NTLM. This led to
different requests sharing the same authentication session which fails
miserably.
Bug #631315 fixed.
If there's a POST/PUT request that gets a NTLM 401, we save the data
and don't send it again until after the challenge phase. Ie, instead of
sending all the data 3 times, we only send it at most twice.
The duplicate-element checking algorithm wasn't restricted to just elements;
consequently, an 'invalid token' exception was generated from XPath because we
were trying to call XmlNode.SelectNodes("#text"), and '#' isn't valid. Oops.
Fixes building gendarme from mono-tools.
Previously, in a (misguided) effort to reduce memory requirements, I loaded
the source document into an XDocument, then wrote it piecemeal to an output
XmlWriter.
- Pro: only one document needed to be kept in memory, and additional
memory was only needed to write replacement //Type nodes.
- Con: since the output document isn't kept in memory, we can't do any
post-processing before writing.
Unfortunately, post-processing is what I want to do: I want to order the
//Type elements by //Type/@Name, which means I need the entire document in
memory _anyway_.
Sorting //Type elements is for the next patch; this just migrates to the "do
everything in-memory" logic.
Generate the //Type/AssemblyInfo/AssemblyPublicKey and
//Type/AssemblyInfo/AssemblyCulture elements based on the values stored in
the index.xml file (which is why we updated mdoc-update to store this).
If index.xml doesn't contain the //AssemblyCulture element, input a default
<AssemblyCulture>neutral</AssemblyCulture> element.
With these changes, we can import the .NET 4.0 reference assembly
documentation and validate the output w/o getting any errors.
Yes, this means we now accept several elements that aren't part of the ECMA
standard, but at least the primary source of information for ECMA will sanely
validate...
The //Member/Attributes element would "move" from after //Member/AssemblyInfo
to the last element within //Member when updating properties and events. This
would result in overly large diff's when no other changes occurred, and
results in 'mdoc validate' stating that the file is invalid.
This is so that `mdoc update-ecma-xml` can use this information when
generating the /Library/Types/Type elements, as //AssemblyPublicKey and
//AssemblyCulture are currently missing from `mdoc update-ecma-xml` output.
* method-to-ir.c (emit_write_barrier): If aot-compiling on
an arch with OP_CARD_TABLE_WBARRIER support, fallback to
the IR based cardtable barrier instead of going with the
remset one.
In mcs/class/corlib/System.Reflection.Emit:
* TypeBuilder.cs (DefineDefaultConstructor): If the resolved
type is either typeof (object) or typeof (ValueType) we backout
to the non resolved type as it might be one of the corlib's
typebuilders.
In mcs/mcs:
* rootcontext.cs (CloseTypes): Only apply the enum hack for
corlib here.
* rootcontext.cs (EmitCode): Do the corlib basic type hack
here before types are emitted. This is required since EmitType
produce type initializers, which derive from ValueType and must
be able to see the TypeBuilder version of it.
* mcs/class/System.Net/System.Net/InternalWebRequestStreamWrapper.cs:
Ensure WebClient.WriteStreamClosedCallback is never called more than
once (even if the stream was closed by the caller). Supply the length
of the data that was written to the stream to WebClient.
* mcs/class/System.Net/System.Net/WebClient_2_1.cs: Keep an Uri of
BaseAddress handy since we'll need it later. Ensure OnWriteStreamClosed
is at least called once (inside finally). Emit UploadProgressChanged
(instead of Download*) when uploading.
* mcs/class/System.Net/System.Net/WebRequest_2_1.cs: Change text for
InvalidOperationException when the URI is not absolute (some MS tests
check for, case-sensitive, "URI").
In the latest revision of the framework, ReaderWriterLockSlim is totally fair and thus a call to TryEnterReadLock musn't succeed when writers are waiting to get the lock before them (and when the lock is currently in read mode).
* method-to-ir.c (emit_write_barrier): Amd64 can't use
big immediates (> 32bits) with ALU operations so
we assert if the cardtable ends been allocated in a high
address.
* sgen-cardtable.c: In order to support cardtables with 64bits we
allow cards to overlap each other. Cards are copied to a shadow
cardtable at the beginning of the scanning.
* gc-internals.h: Change signature of mono_gc_get_card_table to
return the card table mask.
* mini.h: Add PAND_IMM.
* method-to-ir.c: Handle card table masks.
* mini-x86.c: Ditto.
* sgen-cardtable.c: Add functions that test if a given
card or range or cards should be scanned. Those function
make sure the card are clear on return.
* sgen-gc.h: Export new functions.
* sgen-los.c: Use to new functions.
* sgen-marksweep.c: Ditto.
* sgen-cardtable.c: Use live block enumeration API
to clean blocks instead of a custom API.
* sgen-los.c: Add los_iterate_live_block_ranges.
* sgen-marksweep.c: Add major_iterate_live_block_ranges.
* sgen-gc.h: Adjust for new function.
First, we refactor out the "overwrite only if content has changed" logic in
monodocer into MdocFile.UpdateFile() so that we can reuse this same logic.
After that, it's primary all about MDocUpdateEcmaXml.UpdateExistingLibraries():
scan through the document looking for libraries we're interested in. If we
encounter one we don't care about, copy directly. If we do, enumerate it's
contents looking for types we care about, and either copy the old version
as-is if we don't care, or copy over the mdoc(5) version if we do.
This is for ECMA support: it's intended to take an existing
CLILibraryTypes.xml file (from the ECMA 335 standard) and update the specified
types within it. If no existing file is specified, it'll generate a new one
based on command-line arguments.
Update support is currently lacking, but it'll generate a new document with:
mono mdoc.exe update-ecma-xml -o - \
--library BCL --type=System.Environment Test/en.expected
Sometimes the predicate was also called multiple time generating exception that weren't caught by the general Task handler and thus swallowed by the runtime causing Thread shutdown and ultimately deadlocks.
Some concurrent collections don't necessarily guarantee that a call to Dequeue/Pop/equivalent will succeed even in the case there are elements in the collection. When one of such operation fail in test, retry it immediately to check for that sort of cases.
Merge token are simply the combined cancellation source of user (i.e. token supplied with PLinq operator WithCancellation) and internal tokens (supplied with WithImplementerToken).
send(2) does not return ETIMEDOUT for a blocking socket with a write
timeout set, which causes the wrong error code to be reported to the
managed world.
Fixes bug #599488.
* HttpWebRequest_2_1.cs: Avoid using AllKeys (unneeded allocations)
* WebClient_2_1.cs: Copy headers to WebRequest (some special cases are
now considered) then clear them. Expose SecurityException (unwrapped)
and closely match SL4 exceptions (including inner exceptions).
* WebHeaderCollection_2_1.cs: Add missing validations on header names
and values (from original WebHeaderCollection.cs + small fix)
in mcs/class/corlib/System.Reflection:
* MonoProperty.cs: Don't share the same field with
DeclaringType and ReflectedType.
in mcs/class/corlib/System:
* Environment.cs: Dump corlib version.
in mono/metadata:
* appdomain.c: Bump corlib version.
* object-internals.h: Add new field to MonoPropertyInfo.
* icall.c (ves_icall_get_property_info): Store the
declaring type into the new field.
Fixes#633671
'gmcs /doc' now properly generates explicitly implemented interface member
//member/@name values, so mdoc-update can now find them for the import. Yay!
The //member/@name for explicitly implemented interface members needs to
contain the fully-qualified interface name, including type parameters (if
necessary), so we need to generate
"M:Container`2.Element.System#ICloneable#Clone", not
"M:Container`2.Element.ICloneable.Clone".
Furthermore, explicitly implemented generic interface methods within a generic
type were always getting the type parameter count appended to them (which
somewhat makes sense, as they're on a generic type...) which is counter to what
CSC generates, e.g. we need to generate
"P:Container`2.System#Collections#Generic#IList<TValue>#Item(System.Int32)"
not "P:Container`2.IList`1.Item``1(System.Int32)".
Our previous inline card table write barrier did not perform
any checks on the pointers, which means that it marked cards
for the major heap even if the references stored there were
not to nursery objects. Doing that is slightly faster in the
mutator but the nursery collections might take a lot longer
because objects might have to scanned unnecessarily.
This patch implements an inline write barrier that also
performs a nursery check. To that end we introduce a new
IL opcode, OP_CARD_TABLE_WBARRIER.
It is currently only implemented on x86. For architectures
that don't support it (yet), we automatically regress to the
old, non-checking write barrier.
There was still an issue with thread-safety of binary protocols: If
the world was stopped while a thread was in the process of using a
binary protocol buffer, the GC would write all buffers to the file and
release the memory, making the thread crash once it restarted.
We fix this here by keeping a count of how many threads currently use
the buffers. If they are in use when we try to save and free them, we
don't. They'll be saved and freed eventually.
* mini.c (create_jit_info): Handle the case where the basic
block right after a try block is dead. For example:
.try {
....
leave ...
}
nop //HERE
.catch {
...
}
The above nop is dead code and the branch opts will nullify it
which caused the code in create_jit_info to assert when
calculating the try block lenght.
This is a very rare case since only obfuscators or broken
compilers would put instruction between the try and handler
blocks.
The fix is to simply iterate over all CIL addresses of the
try block in reverse order looking for the first block which
was not removed.
Fixes 633291
Since the call is also implemented as a simple long load operation in the runtime when on x86-64 there is no need to do the differentiation in managed code.
No mdoc changes, but since 'mdoc update --exceptions=all' scans across
assemblies, and since System.Delegate.Combine() now throws additional
exceptions (according to our IL scanning algorithm), the expected output
differs, leading to false negatives about regressions.
Furthermore, 'gmcs /doc' has been fixed (it used to cause a compilation
error) and improved, so more XML documentation is now imported because gmcs is
generating the correct XML documentation crefs. (Go gmcs, go!)
Fixes#624242
This also allows master 'gmcs /doc' to build OpenTK, gitorious.org/cadenza,
and build the mcs/tools/mdoc unit tests w/o compilation error.
The bug was caused by a NotSupportedException when calling ArrayContainer.Name
within DocUtil.GetSignatureForDoc(TypeSpec). This is directly fixed by
checking explicitly for ArrayContainer.
Another bug fixed was wrt type parameter indexing in nested types, hence
"counting" the number of type parameters declared in all declaring types.
When a server-side control processes its children (in the markup) as properties, it needs to instantiate
an object of the property type and assign it to the appropriate property of the control. Failing to do so
will cause markup which references properties to fail in certain cases (for instance when the control's
property type is a class and it is not instantiated by the control's constructor).
If the card table write barrier is used, emit it inline.
It's a quick address calculation and a single store, so
it's much more efficient than our old write barrier.
This is a direct card table, meaning there is only card table
level, which makes it very simple and efficient. It only works
on 32 bits at this point, and only for Mark&Sweep.
Move the CAS related code out of the
if (rs->ifree_mask & (regmask (dest_sreg))) {
section so it is executed even if the fixed sreg is already assigned.
* ObjectWriter.cs: Make the .ctor take a single BinaryFormatter
parameter and get the information from there. This should make
it easier to do some 4.0 new assignations, instead of adding yet
another parameter (also, ObjectReader is doing exactly what we
are doing here now).
* BinaryFormatter.cs:
* MessageFormatter.cs: Update call sites.
There is a possible crash using this profile if the monotouch.dll
isn't loaded into the process space. We will null guard the
type and only call start_wwan if its present.
QueryCheckerVisitor can then eventually decide if it's pertinent to run the query in parallel and set accordingly a boolean value (though not used by the engine at the moment).
Increase the sizes of the various load/store opcodes in order
to support the expansion when large stack frames (>32k) are
produced. Update prologue and epilogue code to generate the
frame in two steps.
Code contributed under the MIT/X11 license.
Because we were using the wrong handle in SetConsoleMode, newlines were breaking when TreatControlCAsInput was enabled. This no longer happens now that we're setting the correct mode on the input handle instead of the output handle.
If xbuild is unable to resolve a reference, then it dumps details of
why it failed. This adds a env var XBUILD_LOG_REFERENCE_RESOLVER,
which if set, logs those details of why a particular search path
was used to resolve the reference.
Update the man page also.
This is necessary for some PLinq operator that can provide a better optimized version of themselves when there is no ordering constraint whithout having to create yet another query node. Note that the method can be optimized with a more specialized version of the visitor.
Previously the case of Unordered wasn't taken in account and the control flow wasn't properly forwarded to the following nodes in the query# Please enter the commit message for your changes. Lines starting
Using ToArray directly, even though incorrect, was working by a twist of fate in that the mostly-standard partitioner and ToArray operator were based on the same assumptions.
Switch from manually creating result sets to creating them with a Linq query. Replaced some type with var. Split indexed and non indexed call in two different virtual method call.
In some rare case where a ThreadWorker have taken more than one item (and thus there are items to steal) another ThreadWorker that hadn't seen this extra work would go to sleep indefinitely and cause deadlock if the first Task executed was depending on another Task to be launched.
* MonoField.cs (FieldType): Lazy load the field type if
null.
* icall.c (ves_icall_MonoField_ResolveType): New icall
to lazy resolve a field.
* icall-def.h: Ditto.
* reflection.c (mono_field_get_object): Eager load a field's
flags since this simplifies a lot the managed side that doesn't
have to handle loading it if not present.
* class-internals.h: Add mono_field_is_deleted_with_flags
which takes the flag as an argument instead of using the
value on type->attrs.
* reflection.c (mono_field_get_object): Check if field->type
is present before using it.
* icall.c (ves_icall_Type_GetFields_internal): Do things
lazier by not depending on a field's type been loaded.
* class.c (mono_class_get_fields_lazy): Lazy variant
of mono_class_get_fields that returns fields with only
minimal information loaded (name and parent).
* class.c (mono_class_setup_basic_field_info): Loads minimal
info about a field, right now just name.
* class.c (mono_class_setup_fields): Use new functions to
load everything.
* class.c (mono_field_resolve_type): Init the error struct
and set it on case of a class failure.
* class.c (mono_field_get_flags): Since the field type
is lazy loaded we avoid loading it here since some
reflection operations depends on flags but require lazy
loading of type.
* DataGridView.cs: When refreshing the scrolling info,
set the values for the internal scrollbars even if we are forced
to not display them, since they are used to compute the
navigation, which should be available *always*.
* TextBoxBase.cs: In Text property always call
Document.SetSelectionToCaret just like we do in other places
calling Document.Empty(). This way we don't leave our selection
stuff in an inconsistent state.
Instead of a do/while loop, just keep looping until both KeyDown is true, and EventType == 1. It seems that sometimes when EventType == 1, KeyDown wasn't true but it would stop looping anyway. This caused mouse presses, context menu changes, and focus changes to register as key presses. With the new infinite loop, only actual key presses will be registered.
ConcurrentDictionary is now used to store the per-thread CyclicDeque instances instead of maintaining a growing array ourselves. Add hints are still used.
When one clicks on the plus sign in the tree with populate on demand active and then clicks on the node's
text, the resulting post back is a plain one, not a callback. In this case all the nodes need to be repopulated
or they will vanish from the rendering. At the same time, the nodes have to be simply marked as populated when
a post back in callback mode is processed.
Disabled one test and a small chunk of code in TreeView.RenderNode - it needs more investigation (nothing critical
though)
__CALLBACKTARGET and __CALLBACKARGUMENT have been renamed to __CALLBACKID and __CALLBACKPARAM, respectively,
recently and this script didn't get update for the change causing callbacks not to work on master.
* icall.c (ves_icall_MonoType_get_Module): Don't mono_class_init
the type as it's not needed.
* icall.c (ves_icall_MonoType_get_Assembly): Ditto.
* icall.c (ves_icall_System_Reflection_Assembly_InternalGetType):
mono_reflection_get_type can return a non-null type and set a
loader error. Don't leak it.
Fixes#630773
Several method in ConcurrentDictionary do a combination of two actions or two different actions depending on a test. These additional methods to the standard SplitOrderedList operation set are for these.
This data structure is to be used internally by ConcurrentDictionary. Theory from paper "Split-Ordered Lists: Lock-Free Extensible Hash Tables" and "A Pragmatic Implementation of Non-Blocking Linked-Lists".
When GridView auto-generates columns it uses reflection to retrieve list of public properties present
in the item type. Only the properties that have bindable type and are declared directly in the item
type must be considered for column auto-generation.
in mcs/class/corlib/System.Reflection:
* CustomAttributeData.cs: This now receives only the information
required to later load argument data. This information is stored
in a new field that is later discarded.
in mono/mono/metadata:
* icall-def.h: Add new icall from CustomAttributeData.
* object-internals.h: Add new reflection.c function.
* reflection.c (mono_reflection_get_custom_attrs_info): Don't
init the class when retrieving custom attributes since we must
handle broken types.
* reflection.c (create_custom_attr_data): Don't resolve cattr
arguments eagerly. Instead pass enough information to
CustomAttributeData so it can later on create them.
* reflection.c (mono_reflection_resolve_custom_attribute_data):
new icall used to create the cattr data arguments.
This is required to match MS behavior and fix some of the issues
triggered by trying to compile MD.
Fixes#630074
WebConfigurationHost now supports one more parameter passed to it in InitForConfiguration -
a boolean telling whether the configuration being initialized belongs to another app. If it is
true then the virtual path passed to InitForConfiguration is used as the application virtual
path. This has the effect that IsDefinitionAllowed doesn't throw an exception when a configuration
element with the MachineToApplication level is parsed.
WebConfigurationManager.FindWebConfig checks whether the path passed to it belongs to this application
which allows the mechanism described in the first paragraph to work.
When HttpContext.RewritePath is passed a virtual path with more than one leading slash it
results in HttpApplication.GetHandler not being able to locate the appropriate handler.
Patch adds code to convert the passed virtual path to a canonical form.
Additionally, HttpApplication.Pipeline () now throws an exception when no handler can be
determined for the current request.
The bug was caused by the runtime loading two copies of System.Configuration -
one for the 4.0 profile (loaded by xsp4 itself) and another for the 2.0 profile
(loaded as a reference for BlogEngine.Core.dll) and for that reason, the static
class System.Configuration.ConfigurationManager was instantiated twice in the
BlogEngine application's AppDomain which, in effect, led to the exception since
the configuration system wasn't reset from the default one to the system.web-specific
one. The commit makes runtime remap System.Configuration 2.0 to 4.0.
Thanks to Zoltan Varga for catching the issue.
When the in-proc session handler puts items in the internal cache, it prefixes them with the
@@@InProc@ prefix to make sure they don't conflict with other values stored there. The handler
has been failing so far to remove that prefix when triggering the session end event. This commit
fixes the issue.
* Application.cs: At the end of the message loop in RunLoop
don't break the loop if the Form handle has been destroyed already -
which means that we *need* to wait for WM_QUIT and handle it
properly instead, so it doesn't end up affecting other forms.
In the parallel collector, the main GC thread needs to distribute all
remaining entries in the gray queue to the worker threads. Since the
distribution pool is limited in size we need to wait on it, which at
this point is only possible with busy-waiting. Since we don't want to
use up CPU resources and hog the cache lines we wait 2ms between
distribution attempts.
* mcs/class/System.Configuration/System.Configuration/InternalConfigurationHost.cs: Add new internal call to retrieve embedded application config. First
check if an embedded configuration exists before looking up on the
filesystem.
* mono/metadata/icall-def.h: Add entry for retrieving embedded application
configuration.
* mono/metadata/icall.c: Add function to retrieve embedded application
configuration if one has been registered with the runtime.
* Ping.cs: generates a random ICMP Identifier field per Echo to help
match up pings and their responses. Now has valid TTL and timeouts apply to
the correct pings. Also fixed bugs were received Sequence and
Identifier would be corrupt for values >255, and fixed corruption of
the Data field.
Patch by Michael Walsh that fixes bug #627330.
When a postback is made to the server, AsyncPostBackTrigger.HasTriggered must use FindTargetControl (true)
to find the associated control and see if its UniqueID matches the one of the control which originated
the postback. The target control may (and most probably is) outside the control panel and looking for it
only in the collection of child controls will make some sites fail to update content on async postback.
AsyncPostBackTrigger must search for the associated control in the naming containers during intialization
because its ControlID property is initialized with the unique name of the target control.
* ListView.cs: When using Details view re-populate our implicit
control collection to our header control is always on top. We
could try to just use BringToFront but since these controls are
implicit, we are not gracefully handling them.
* ListView.cs: Don't call Dispose for our implicit scrollbars,
as the default Control.Dispose impl is already disposing all the
implicit controls. This was generating extra Layout
events when disposing.
This is a new variant of Mark&Sweep which uses a pre-allocated
fixed-size heap instead of a dynamically grown, segmented one. The
main advantage of this heap organization is that it takes only one
pointer comparison to determine whether an object is on the small
object heap or in the LOS, instead of inspecting the object's size,
which requires three loads. Since that determination is required for
every marked object, speeding it up can improve performance
significantly.
Make the parallel Mark&Sweep collector selectable with the "major"
option of the "MONO_GC_PARAMS" variable as "marksweep-par". The
serial Mark&Sweep collector remains the default as "marksweep".
Previously we used one internal allocator. That was not a problem as
long as SGen was single-threaded. With parallel mark, however, we
needed a lock for the internal allocator to make it work. This patch
makes each worker thread use its own internal allocator instead, so we
don't have to lock anymore.
One problem introduced by this approach is that the allocator from
which a gray queue section was allocated is not known at the point where
the section is freed, because it might have been sent off to a different
worker thread. To solve this we have a "delayed" free function, which
determines the correct internal allocator from the internal allocator
block (which is aligned). The section is then added to a delayed free
queue of that allocator which is processed at some point by that
allocator's worker thread.
Note that the section cannot be freed by the thread that calls the
delayed free function because that would result in the possibility of
the "ABA" problem occuring.
Make the mark phase of the Mark&Sweep collector parallel.
At GC initialization we start a number of worker threads (as much
as the machine has cores) between which the objects in the gray
queue are distributed for marking.
* Microsoft.Win32.SafeHandles/SafeRegistryHandle.cs: Implement
ReleaseHandle by pinvoking RegCloseKey if we are on windows, and
nothing otherwise.
* Microsoft.Win32/Win32RegistryApi.cs:
* Microsoft.Win32/RegistryKey.cs: Don't call SafeHandle.Close
from our public api, and do it instead un the windows layer, as
we only support it there for now.
ASP.NET 4.0 allows one to set base types for Pages, User Controls, Application and PageParserFilter
from the pre-application start method(s). This commit implements support for this mechanism.
* ApplicationFileParser.cs: added override of DefaultBaseType property which checks whether
PageParser.DefaultApplicationBaseType is set and, if yes, uses it to set application base type
if there's no custom Global.asax
* PageParser.cs: implemented the EnableLongStringsAsResources, DefaultPageBaseType, DefaultApplicationBaseType,
DefaultPageParserFilterType and DefaultUserControlBaseType properties.
* TemplateParser.cs: if PageParser.DefaultPageParserFilterType is set, use it as the default type to create instance
of the page parser filter
* Added tests for the new properties.
* Added support in standalone runner for setting custom application domain data on domain creation, just before
the test is ran.
* marshal.c (mono_marshal_get_delegate_invoke): add support for
delegates pointing to instance methods that are closed over null.
Managed side of the feature is in 2ec0ab59fe.
If an app uses e.g. System.Diagnostics.Trace (and the Trace methods are
actually invoked, e.g. by building with -d:TRACE and using Trace.WriteLine()),
at least one System.Configuration.ConfigurationErrorsException was being
generated as part of startup (one from parsing machine.config, and an optional
second exception from parsing AppName.exe.config).
The exception was caught, so it didn't break anything, but it was still
undesirable.
The cause of the exception is as follows: The <system.diagnostics/>
configuration section is processed by DiagnosticsConfigurationHandler, which
is an IConfigurationSectionHandler implementation. In .NET 2.0, configuration
file processing was moved to use System.Configuration.ConfigurationSection
implementations, which would delegate to IConfigurationSectionHandlers if/when
specified.
However, before ConfigurationSection.GetRuntimeObject() calls into
DiagnosticsConfigurationHandler, it would indirectly call
ConfigurationElement.DeserializeElement() to process the e.g.
<system.diagnostics/> element, which would throw as ConfigurationElement was
hitting "unrecognized" XML elements (as ConfigurationElement doesn't know about
DiagnosticsConfigurationHandler-specific XML). This would result in a
ConfigurationErrorsException, which would be caught in GetRuntimeObject(),
then DiagnosticsConfigurationHandler.Create() would be invoked (doing the
"actual" <system.diagnostics/> parsing, allowing Trace to work, etc.
The fix taken here is to avoid calling
ConfigurationElement.DeserializeElement() if there's an
IConfigurationSectionHandler present, as it doesn't make sense to parse the
same section with two different handlers.
Make implementors of IInternalConfigurationHost.OpenStreamForRead return null instead of throwing an exception when there's no usable configuration file and deal with null at the call site.
This adds support for the ProviderName attribute of the OutputCache directive in user controls.
Also implemented missing support for SqlDependency attribute.
* TemplateControlCompiler.cs: StaticPartialCachingControl instantiation now uses the constructor overloads
which accept sqlDependency (2.0+) and providerName (4.0+)
* UserControlCompiler.cs: added code to output PartialCachingAttribute which accepts sqlDependency (2.0+) and
ProviderName (4.0+) arguments
* PartialCachingAttribute.cs added the 4.0 ProviderName property
* StaticPartialCachingControl.cs: implemented two missing constructors (one 2.0 and the other 4.0)
Added a missing BuildCachedControl overload which accepts providerName (4.0)
* TemplateParser.cs: factored out OutputCache attribute processing to a separate internal virtual method.
* UserControlParser.cs: added support for the ProviderName attribute of the OutputCache directive.
This commit implements the ability to programmatically set the name of the output cache provider
to hold cached control data.
* OutputCache.cs: added DefaultProvider internal property to return whatever default provider is
configured.
Added GetProvider() method to return instance of a named provider
* BasePartialCachingControl.cs: cache key and cached data are store in instance fields.
Added 4.0 internal property ProviderName which names the output cache provider to use for storage.
Removed OnInit from 4.0 profile, replaced with an override of Control's InitRecursive. Control is
created only when cached data is not found in the provider.
* Control.cs: made InitRecursive virtual for the benefit of BasePartialCachingControl above.
* ControlCachePolicy.cs: added 4.0 property ProviderName
When doing a rebuild for an already built project, the common
files (CopyLocal) should not be deleted by a project, as
other projects might be depending on them. This becomes a problem
when a common output dir is used.
Since "make dist" should also work from a tarball we must only call
the commit-to-changelog script if there's a git repository present.
If we're already in a disted tree, the script has already run.
The commit-to-changelog script now fails if git fails for whatever
reason. The most important reasons would be that git isn't installed,
and that the script is called without a repository.
* reflection.c (reflection_methodbuilder_to_mono_method):
Handle the case where a method parameter is defined using
a generic argument of another method. The resulting signature
must use the generic arguments of the method it belongs and
not from others.
This fixes one issue found while testing IronRuby 1.1.
* BuildProvider.cs: factored out build provider type retrieval code to a separate method
* BuildProviderCollection.cs: factored out build provider type retrieval code to a separate method
* BuildManagerDirectoryBuilder.cs: system.web/compilation section is not an application section - it can
be defined in web.config on any level.
* metadata-verify.c (mono_method_signature_checked): Change
signature to take a MonoError* instead of a GList** to make
it easier to the runtime to get error messages out of the
metadata verifier.
* verify-internals.h: Change signature.
* loader.c (mono_method_signature_checked): Pass the current
MonoError to mono_method_signature_checked to get better
error messages.
* metadata-verify.c (init_verify_context): Change parameter
from GList** to gboolean so it can be used with functions that
don't receive a GList** argument.
* mini-exceptions.c (mono_install_handler_block_guard): Guard against a
null MonoJitTlsData. This can happens if the thread receives the
interrupt signal before the JIT has time to initialize its
TLS data for the given thread.
When loading projects specified in the solution file, to find
their dependencies, missing imports cause an exception to be
thrown and so the deps are not available in the project instance.
MSBuild task can override properties for a project, and these
should be applied before the project file is loaded. This is to
allow the properties to be available for Imports. Eg.
<Import Project="$(SolutionDir)\foo.targets"/>
$(SolutionDir) is generally set by the MSBuild task in a .sln.proj
file.
Bug reported by JB Evain.
* Microsoft.Build.BuildEngine/Engine.cs:
Apply global properties before the project load.
* Test/*/EngineTest.cs (TestGlobalPropertiesImport*): New tests.
The major collector refactoring left heavy statistics broken. A few
heavy statistics counters are defined in sgen-gc.c but used in the
major collectors. We're now exporting them. Another possibility
would have been to define them in both major collectors, but since
this is only a debug feature that's not normally compiled in, we don't
care.
Make the major collectors define their own versions of
major_scan_object() by including a small header file. This
avoids indirect calls to major_copy_or_mark_object() and
allows inlining.
Instead of using solely SpinWait's SpinOnce method after ManualResetEventSlim's spinCount is reached, it now uses ManualResetEvent's WaitOne method. Various other checks like CancellationToken canceled state are still verified during that time albeit slower.
Instead of shutting down the thread when there is no more work to do, each ThreadWorker will now block on an EventWaitHandler and be awoken later by Scheduler.
* xbuild/xbuild/*/Microsoft.Common.targets: Rename item
@(TargetFrameworkDirectories) to @(_TargetFrameworkDirectories)
to *mark* it as private, and use the new $(TargetFrameworkDirectory)
property instead. Reported by mhutch.
* xbuild/xbuild/*/Microsoft.Silverlight.Common.targets: Update
to track the changes.
2010-08-02 Zoltan Varga <[email protected]>
* tramp-amd64.c (get_vcall_slot): Move mono_arch_get_vcall_slot () here, since it
is only used by this file.
* tramp-x86.c: Ditto.
* mini-trampolines.c mini-<ARCH>.c: Get rid of mono_arch_get_vcall_slot (), all
architectures should support MONO_ARCH_THIS_AS_FIRST_ARG now.
* RegistryKey.cs: Implement Handle, but only for Windows, since
we don't have any unmanaged api to access the registry - and our
unix impl is fully managed anyway. Also rename our internal
Handle property to InternalHandle.
* Win32RegistryApi.cs:
* UnixRegistryApi.cs:
* IRegistryApi.cs: Add a GetHandle method, and update calls to
RegistryKey.Handle to use InternalHandle instead.
* RegistryKey.cs: Implement the simple overloads of OpenBaseKey,
OpenRemoteBaseKey, FromHandle that take a RegistryView
parameter, which we ignore, as well as adding View property.
* Win32RegistryApi.cs:
* RegistryKey.cs: Implement RegistryKey.FromHandle method,
supported only on Windows as there is not any unmanaged
convention to retrieve a handle for a given key.
* Win32ResultCode.cs: Add InvalidHandle code.
* UnixRegistryApi.cs:
* IRegistryApi.cs: Update overloads.
* Makefile.am: added 2 new tests
* threadpool-exceptions6.cs: new thread.abort inside the threadpool
test.
* appdomain-unload.exe.config: this test does not work in .NET without
having the legacy unhandled exception mode enabled.
* RegistryKey.cs: Implement the 4.0 overload of DeleteSubKeyTree
that takes a boolean to throw an exception if the key is not
found. Just expose our already existing method as an internal
overload for 2.0.
This reverts commit 3c53388c59.
The LLVM version which required this change is broken, so revert this change
along with reverting the 'mono' branch in the mono/llvm repo to a working version.
This fixes EOL conversions flagged by git 1.7.1 core.autocrlf=true. At this
point, neither git 1.7.1 nor 1.7.2 show any automatic CRLF normalization.
I think we're ready for another experiment.
There seems to be a difference in the handling of mixed line-ending files
between git 1.7.2 and older versions, when core.autocrlf is set to true.
* mini/debug-debugger.c
(MONO_DEBUGGER__debugger_info): Add 'thread_abort_signal', pointing
to a field store the signal number on startup.
* metadata/mono-debug.h: Bump debugger version to 81.6.
The commits-to-changelog script previously generated ChangeLog entries
with a FIXME if it couldn't find anything applicable for that
particular ChangeLog. Since we want to use the script for "make dist"
it shouldn't do this. Instead it now just inserts the whole commit
message in those ChangeLogs.
When creating a distribution "make dist" now uses the
commits-to-changelog script to automatically update all
ChangeLog files since the last commit marked with the
"last-commit-with-compulsory-changelog-entry" tag.
This script converts git commit messages to ChangeLog entries. That
will hopefully allow us to forego adding ChangeLog entries in our
commits, which always leads to merge conflicts.
* UnixRegistryApi.cs: Move GetSubKeyCount and GetSubKeyNames to
KeyHandler, so we can properly track volatile subkeys there
*without* exposing any impl details.
* mono/tests/threadpool-exceptions[1-4].cs: new tests
* mono/tests/threadpool.cs: fix typo.
* mono/metadata/threadpool.c: starting in .NET 2.0, unhandled exceptions
in the threadpool can cause a crash in a running program. From now on,
we are compatible.
Until now exceptions thrown from a threadpool work item were ignored.
From now on they will propagate to the domain's UnhandledException event
and then to the root AppDomain. If they are not handled, they will cause
the program to abort.
2010-07-29 Rodrigo Kumpera <[email protected]>
Add support for calling vararg methods from SRE code.
This requires storing per-memberref signatures so
the JIT can know how many varargs parameters are
been passed.
* loader.c (mono_method_get_signature_full): If the
image is dynamic call mono_reflection_lookup_signature
to lookup the signature.
* reflection.c (mono_image_create_method_token): Save
the method object into the MonoDynamicImage::tokens.
Create a signature struct for MethodBuilders.
Save the signature into vararg_aux_hash so it can be
retrieved later.
* reflection.c (mono_reflection_lookup_signature): New
function. Check vararg_aux_hash for a signature before
returning method's own signature.
* metadata-internals.h (MonoDynamicImage): Add new
vararg_aux_hash hashtable.
* object-internals.h: Add mono_reflection_lookup_signature.
Fixes#626441
2010-07-28 Rodrigo Kumpera <[email protected]>
* verify.c (mono_method_verify): Don't move forward
with verification if a stack overflow is detected for
the ARGLIST opcode.
Fixes#601953
2010-07-28 Rodrigo Kumpera <[email protected]>
* class.c (mono_bounded_array_class_get): Fail arrays
of void or typedbyref. Those two types are not allowed
to be used with arrays. Failing them is easier and less
error prone than returning NULL.
Fixes#603279
2010-07-28 Rodrigo Kumpera <[email protected]>
* object.c (mono_get_delegate_invoke): Don't assert if
the Invoke method is not found. This can happen with
broken types and it's the caller resposibility to deal
with a null return.
Fixes#553403
2010-07-28 Rodrigo Kumpera <[email protected]>
* class.c (mono_assembly_name_from_token): Handle
images with null assembly. This can happen with resource
or broken assemblies.
Fixes#623586.
2010-07-27 Rodrigo Kumpera <[email protected]>
* class.c (concat_two_strings_with_zero): Guard against
null strings.
Modified version of patch by Sebastien Pouliot.
Fixes#623653.
2010-07-27 Rodrigo Kumpera <[email protected]>
* image.c (mono_image_load_module): Handle the case of
module index equal or smaller than zero. It is possible
to embed a valid zero index into metadata so this case
must be explicitly handled.
Patch by Sebastien Pouliot.
Fixes#623581.
2010-07-27 Rodrigo Kumpera <[email protected]>
* metadata-verify.c (INVALID_IMPLMAP_FLAGS_BITS): Add non standard
bits for best fit on/off (4,5) and throw on unmappable on/off (12/13).
Fixes#622221.
* JsonSerializationReader.cs, JsonSerializationWriter.cs:
Add a special case for IDictionary, since KeyValuePair objects
have private setters and can't be processed via the normal
object code path.
2010-07-27 Rodrigo Kumpera <[email protected]>
* EventLogger.cs: Emit verifiable code. This was blocking the
SWF test suite from running under the verifier.
In metadata:
2010-07-27 Geoff Norton <[email protected]>
* sgen-archdep.h: Ensure we store the registers we actually
need to scan.
In utils:
2010-07-27 Geoff Norton <[email protected]>
* mono-sigcontext.h: Extend the macro's for darwin and linux
to expose r8-r11 as well.
* verify.c (mono_generic_param_is_constraint_compatible): Don't
fail a contraint check even if the candidate has no constraints.
All constraints might resolve to the candidate itself so it can
have none.
Fixes#622225.
* FederatedMessageSecurityOverHttpElement.cs : use correct converter.
* WSFederationHttpBindingCollectionElement.cs : remove extra members.
* WSDualHttpBindingElement.cs, WSFederationHttpBindingElement.cs :
fill base properties expectedly.
* UnixRegistryApi.cs: From the static ctor of KeyHandler remove the
volatile keys directory if the last registered boot time has changed.
This way we *actually* have our volatile keys removed if the system as
rebooted.
This is a scripted conversion of mixed line-ending files to LF-only or CRLF-only
based on which patch is smaller. I used a threshold of upto a quarter of the
lines to determine whether to keep the patch or not.
This set of .gitattributes was automatically generated from the list of files
that GIT tried to normalize when I enabled automatic EOL conversion.
With this set of attributes, we prevent automated EOL conversion on files that
we know will cause trouble down the road.
2010-07-24 Mark Probst <[email protected]>
* sgen-internal.c, sgen-gc.h, sgen-major-copying.c: Make the
internal allocator fast by keeping free-lists of chunks, not only
within chunks. Align the chunks, so that on freeing we can get
the chunk without searching.
2010-07-24 Mark Probst <[email protected]>
* sgen-internal.c, sgen-gc.c, sgen-gc.h, sgen-gray.c,
sgen-major-copying.c, sgen-marksweep.c, sgen-pinning-stats.c,
sgen-pinning.c: Allocate fixed-size structs without specifying the
size, instead registering it once with its type.
Dynamically-sized need their size specified when being freed.
2010-07-24 Mark Probst <[email protected]>
* sgen-major-copying.c, sgen-internal.c, sgen-gc.c, sgen-gc.h,
sgen-pinning.c: Copying major collector doesn't mess around with
internals of the internal allocator anymore, instead using public
functions.
2010-07-24 Mark Probst <[email protected]>
* sgen-internal.c: Internal allocator in its own module.
* sgen-gc.c, sgen-gc.h, sgen-gray.c, sgen-los.c,
sgen-major-copying.c, sgen-marksweep.c, sgen-pinning.c,
sgen-pinning-stats.c: Remove internal allocator and call the
public functions now.
* Makefile.am: Added new file.
* mini-darwin.c: Having reviewed xnu-1504.7.4 it is safe to call fork directly
here, it seems the old implementation was a hold over from the linux behaviour
This fixed gdb backtrace on amd64 and ppc.
** Fixes#565616 - Based on Patch by Hubert FONGARNAND
* DataContainer.cs (GetContainerData): If typecode is string,
call Convert.ToString() irrespective of whether value is
IConvertible or not.
* ContractAssertTest.cs
ContractAssumeTest.cs
ContractHelperTest.cs
ContractMustUseRewriterTest.cs:
Mark couple of runtime breaking tests (on .NET 4.0) as [Ignore].
** Fixes#565616 - Based on Patch by Hubert FONGARNAND
* DataContainer.cs (GetContainerData): If typecode is string,
call Convert.ToString() irrespective of whether value is
IConvertible or not.
* ContractAssertTest.cs
ContractAssumeTest.cs
ContractHelperTest.cs
ContractMustUseRewriterTest.cs:
Mark couple of runtime breaking tests (on .NET 4.0) as [Ignore].
* loader.c (mono_loader_lock_if_inited): New helper function which can be called
during startup before the loader lock is initialized.
(mono_loader_unlock_if_inited): Ditto.
* loader.c (mono_loader_lock_if_inited): New helper function which can be called
during startup before the loader lock is initialized.
(mono_loader_unlock_if_inited): Ditto.
* MenuRenderingMode.cs: added (4.0)
* Menu.cs: added the IncludeStyleBlock and RenderingMode 4.0
properties (not used in the code yet).
svn path=/trunk/mcs/; revision=160723
* HttpApplication.cs, HttpRuntime.cs, HttpApplicationFactory.cs:
Prepare for the runtime change that will terminate threadpool
svn path=/trunk/mcs/; revision=160700
* Array.cs: Fixes a couple of other cases where we were missing
the handling for null values, fixes a broken case of null
handling.
svn path=/trunk/mcs/; revision=160699
2010-07-21 Sebastien Pouliot <[email protected]>
* Makefile: Ensure SECURITY_DEP gets defined in our moonlight
raw profile
In System.Net:
2010-07-21 Sebastien Pouliot <[email protected]>
* ServicePointManager.cs: Add special validation for Moonlight
* WebConnection.cs: Change a define to NET_2_1
In System.Net.Security:
2010-07-21 Sebastien Pouliot <[email protected]>
* LocalCertificateSelectionCallback.cs:
* SslStream.cs:
Don't use alias in moonlight build (not needed and breaks
compilation otherwise)
svn path=/trunk/mcs/; revision=160675
* Wizard.cs: made rendering 100% compliant with .NET (button IDs,
2.0+)
Implemented LayoutTemplate (4.0+)
* LinkButton.cs: render id first
* CreateUserWizard.cs: CreateUserNavigationContainer.UpdateState
doesn't add a previous button if we're on the first step.
svn path=/trunk/mcs/; revision=160657
* method-to-ir.c (op_to_op_src2_membase): Reorganize the amd64 op->op membase
code, it was missing a few 'break's.
svn path=/trunk/mono/; revision=160633
* parser.cs (ParseEscape): Now parses with some context, whether
we are parsing inside a character range which can not contain
back-references or when we are parsing on a string context which
can contain back references.
This fixes bug #577346 which exposed a bug parsing this:
new Regex("[\\177-\\377]")
svn path=/trunk/mcs/; revision=160626
* NoAccessPolicy.cs: Set default to SecurityException each time
IsAllowed is called since we share a single instance of this type
svn path=/trunk/mcs/; revision=160611
* src/gmisc-win32.c (g_getenv): Distinguish between variable not
found and an empty variable.
This should fix 566152
svn path=/trunk/mono/; revision=160589
* BaseDomainPolicy.cs:
* ICrossDomainPolicy.cs:
* NoAccessPolicy.cs:
* PolicyDownloadPolicy.cs:
* SiteOfOriginPolicy.cs:
Allow throwing something else than a SecurityException
which is pretty rare but we got a DRT for it
svn path=/trunk/mcs/; revision=160586
* UnixRegistryApi.cs: Remove the in-memmory approach to volatile keys,
as it becomes trickier to handle deep hiearchies, subkeys and values
in some scenarios. So for now we keep them in disk, we in an
alternative directory, so we can cleam them properly later.
svn path=/trunk/mcs/; revision=160574
* Array.cs: Fix for bug #622101, this reverts portions of the
broken patch that was introduced as part of the fix for #351638
which was mostly a set of optimizations, but some were just
wrong.
svn path=/trunk/mcs/; revision=160527
* Graphics.cs (CopyFromScreen): Avoid crash if asked for a region
to big for XGetImage to return. Fix bug #582823
svn path=/trunk/mcs/; revision=160507
* FormViewRow.cs: added internal property RenderJustCellContents
which makes the control render only its children (4.0)
* FormView.cs: implemented RenderOuterTable property and the
ModifiedOuterTableStylePropertyName method (4.0)
svn path=/trunk/mcs/; revision=160496
* WebControl.cs: implemented verifying that no inline style
property is set for controls which support the RenderOuterTable
property (4.0)
* IRenderOuterTable.cs: internal helper interface for controls
which support the RenderOuterTable property (for now only
ChangePassword, 3 more to come)
* ChangePassword.cs: implemented RenderOuterTable property and the
corresponding behavior of not rendering surrounding table when the
property is set to false (4.0).
Modified BaseChangePasswordContainer to not inherit from Table
anymore. Table is an instance variable (always used as the
template container in 2.0) which is optionally (and by default)
used to contain the templates.
svn path=/trunk/mcs/; revision=160459
* mini-ia64.c: Change the calling convention to pass this as first as on other
architectures. Remove some dead code from the get_vcall_slot() and the implementation
of the CALL_MEMBASE opcodes as a result.
svn path=/trunk/mono/; revision=160458
* wthreads.c (CreateThread): Avoid an assert if the stack size specified by the
caller is smaller than the system minimum.
svn path=/trunk/mono/; revision=160457
* reflection.c, class-internals.h, class.c, icall.c: support
reflection of default constant value for Re.Emit properties.
svn path=/trunk/mono/; revision=160447
* reflection.c (load_cattr_value): Add support for encoding
DateTime constants into the blob. Turns out that this is
required by .NET, it was only documented post 1.0.
* icall.c (ves_icall_type_GetTypeCodeInternal): Guard test for
System.Decimal and System.DateTime inside a mono_is_corlib_image
call. A sample program showed that we could return the wrong
TypeCode just by creating a class with those names.
* class.c (mono_is_corlib_image): Exposed this to other metadata/
code.
svn path=/trunk/mono/; revision=160402
* DateTime.cs: This is the Retina Display of DateTime structs.
Unlike our previous Chubby DateTime that took 16 bytes of memory,
this slim version of DateTime only uses 8 bytes.
This fixes a couple of bugs 592221 and 622127. Additionally, it
turns out that the original Microsoft documentation did not spell
this out, but newer versions of the docs state that SetConstant on
a FieldBuilder should be capable of serializing DateTimes (which
is where this issue came from).
This is necessary to fix two crashers exposed by the CLR test
suite.
svn path=/trunk/mcs/; revision=160391
* tests.make: Do not run the tests under the verifier until the
verifier bug is fixed so at least we can see what is going on in
our buildbots.
svn path=/trunk/mcs/; revision=160388
2010-07-14 21:52:25 +00:00
2367 changed files with 123817 additions and 22719 deletions
dnl No, you can not replace the call below with a pkg.m4 macro
dnl
if $PKG_CONFIG --atleast-version=$GLIB_REQUIRED_VERSION glib-2.0; then
have_glib=true;
else
have_glib=false;
have_glib=false
if test "x$PKG_CONFIG" != "xno"; then
if $PKG_CONFIG --atleast-version=$GLIB_REQUIRED_VERSION glib-2.0; then
have_glib=true;
else
have_glib=false;
fi
fi
AM_CONDITIONAL(HAVE_GLIB, $have_glib)
AC_ARG_ENABLE(quiet-build, [ --enable-quiet-build Enable quiet runtime build (on by default)], enable_quiet_build=$enableval, enable_quiet_build=yes)
AC_SUBST(GPOINTER_TO_INT)
AC_SUBST(GPOINTER_TO_UINT)
AC_SUBST(GINT_TO_POINTER)
@@ -159,6 +168,12 @@ AC_SUBST(GUINT_TO_POINTER)
AC_SUBST(GSIZE)
AC_SUBST(GSIZE_FORMAT)
AC_SUBST(G_GUINT64_FORMAT)
AC_SUBST(G_GINT64_FORMAT)
if test x$enable_quiet_build = xyes; then
AC_CONFIG_COMMANDS([quiet], [for i in `find src test -name Makefile.in | sed -e 's/Makefile.in/Makefile/g'`; do if test -f $i; then $srcdir/../scripts/patch-quiet.sh $i; fi; done], [shell=$SHELL])
@@ -489,6 +489,7 @@ if test "${enable_gc_assertions}" = yes; then
AC_DEFINE(GC_ASSERTIONS)
fi
AC_ARG_ENABLE(quiet-build, [ --enable-quiet-build Enable quiet libgc build (on by default)], enable_quiet_build=$enableval, enable_quiet_build=yes)
AM_CONDITIONAL(USE_LIBDIR, test -z "$with_cross_host")
if test "${multilib}" = "yes"; then
@@ -497,6 +498,11 @@ else
multilib_arg=
fi
if test x$enable_quiet_build = xyes; then
AC_CONFIG_COMMANDS([quiet], [for i in `find . -name Makefile.in | sed -e 's/Makefile.in/Makefile/g'`; do if test -f $i; then $srcdir/../scripts/patch-quiet.sh $i; fi; done], [shell=$SHELL])
@if ["$(NO_DIR_CHECK)"="" -a "$(PROFILE)" !="basic"];thenecho"Running make from the mcs directory is not supported. Run make from the parent directory (if using a tarball), or from the directory where the runtime is checked out (if using an SVN checkout).";exit 1;fi
@if ["$(NO_DIR_CHECK)"="" -a "$(PROFILE)" !="basic"];thenecho"Running make from the mcs directory is not supported. Run make from the parent directory.";exit 1;fi
thrownewNotImplementedException("Unknown SQL type "+sql_type);
}
}
privateboolIsLong(shortsql_type)
{
switch(sql_type)
@@ -1430,7 +1430,7 @@ namespace IBM.Data.DB2
returntrue;
}
returnfalse;
}
}
privateobjectGetBlobDataInternal(intcol)
{
if((col<0)||(col>=fieldCount))
@@ -1461,8 +1461,8 @@ namespace IBM.Data.DB2
}
}
return_resultSet[col];
}
}
}
#endregion
}
}
}
#endregion
Loaded 100 of 2367 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.