mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 01:41:18 -10:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
081f745091 |
No files matched your search
@@ -1,41 +1,3 @@
|
||||
2004-09-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* configure.in: added check for kqueue. Patch from Geoff Norton
|
||||
in HEAD.
|
||||
|
||||
2004-08-17 Dick Porter <[email protected]>
|
||||
|
||||
* configure.in: Correct intl library for FreeBSD and OpenBSD.
|
||||
Fixes bug 62884, patch by Tom McLaughlin ([email protected]).
|
||||
|
||||
2004-07-27 John Merryweather Cooper <[email protected]>
|
||||
* configure.in: Disable __thread test (TLS) for FreeBSD as
|
||||
it succeeds on FreeBSD 5.x when it should fail. Fix pthread
|
||||
library detection for FreeBSD 4.x since pthread is embedded
|
||||
in libc_r on this platform. Fix some typos in my host
|
||||
regexes for freebsd.
|
||||
|
||||
2004-07-23 Dick Porter <[email protected]>
|
||||
|
||||
* configure.in: Changes for FreeBSD thread support by John
|
||||
Merryweather Cooper <[email protected]>.
|
||||
|
||||
2004-07-03 Zoltan Varga <[email protected]>
|
||||
|
||||
* configure.in: Add --with-tls option to replace the misnamed
|
||||
--with-nptl option.
|
||||
|
||||
2004-06-30 Zoltan Varga <[email protected]>
|
||||
|
||||
* configure.in: Fix trunc check + add SPARC64 defines.
|
||||
|
||||
* marshal.c (mono_marshal_get_managed_wrapper): Handle returning
|
||||
delegates from a delegate. Fixes #61033.
|
||||
|
||||
2004-06-29 Jackson Harper <[email protected]>
|
||||
|
||||
* man/gacutil.1: Update man with new command line options.
|
||||
|
||||
2004-06-29 Raja R Harinath <[email protected]>
|
||||
Atsushi Enomoto <[email protected]>
|
||||
|
||||
|
||||
+10
-102
@@ -1,7 +1,7 @@
|
||||
AC_INIT(README)
|
||||
AC_CANONICAL_SYSTEM
|
||||
AM_CONFIG_HEADER(config.h)
|
||||
AM_INIT_AUTOMAKE(mono,1.0.2)
|
||||
AM_INIT_AUTOMAKE(mono,1.0)
|
||||
AM_MAINTAINER_MODE
|
||||
|
||||
AC_PROG_LN_S
|
||||
@@ -67,62 +67,7 @@ case "$host" in
|
||||
libdl=
|
||||
libgc_threads=no
|
||||
;;
|
||||
# these flags will work for all versions of -STABLE
|
||||
#
|
||||
*-*-*freebsd4*)
|
||||
platform_win32=no
|
||||
if test "x$PTHREAD_CFLAGS" = "x"; then
|
||||
CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE -DGC_FREEBSD_THREADS"
|
||||
libmono_cflags="-D_THREAD_SAFE"
|
||||
else
|
||||
CPPFLAGS="$CPPFLAGS $PTHREAD_CFLAGS -DGC_FREEBSD_THREADS"
|
||||
libmono_cflags="$PTHREAD_CFLAGS"
|
||||
fi
|
||||
if test "x$PTHREAD_LIBS" = "x"; then
|
||||
LDFLAGS="$LDFLAGS -pthread"
|
||||
libmono_ldflags="-pthread"
|
||||
else
|
||||
LDFLAGS="$LDFLAGS $PTHREAD_LIBS"
|
||||
libmono_ldflags="$PTHREAD_LIBS"
|
||||
fi
|
||||
need_link_unlink=yes
|
||||
AC_DEFINE(PTHREAD_POINTER_ID)
|
||||
libdl=
|
||||
libgc_threads=pthreads
|
||||
# TLS isn't implemented at all on -STABLE
|
||||
with_nptl=no
|
||||
with_tls=pthread
|
||||
;;
|
||||
# older versions of -CURRENT will break with these flags but testing
|
||||
# indicates these older versions won't run Mono anyway
|
||||
#
|
||||
*-*-*freebsd5*)
|
||||
platform_win32=no
|
||||
if test "x$PTHREAD_CFLAGS" = "x"; then
|
||||
CPPFLAGS="$CPPFLAGS -DGC_FREEBSD_THREADS"
|
||||
libmono_cflags=
|
||||
else
|
||||
CPPFLAGS="$CPPFLAGS $PTHREAD_CFLAGS -DGC_FREEBSD_THREADS"
|
||||
libmono_cflags="$PTHREAD_CFLAGS"
|
||||
fi
|
||||
if test "x$PTHREAD_LIBS" = "x"; then
|
||||
LDFLAGS="$LDFLAGS -lpthread"
|
||||
libmono_ldflags="-lpthread"
|
||||
else
|
||||
LDFLAGS="$LDFLAGS $PTHREAD_LIBS"
|
||||
libmono_ldflags="$PTHREAD_LIBS"
|
||||
fi
|
||||
need_link_unlink=yes
|
||||
AC_DEFINE(PTHREAD_POINTER_ID)
|
||||
libdl=
|
||||
libgc_threads=pthreads
|
||||
# TLS is only partially implemented on -CURRENT (compiler support
|
||||
# but NOT library support)
|
||||
#
|
||||
with_nptl=no
|
||||
with_tls=pthread
|
||||
;;
|
||||
*-*-*openbsd*)
|
||||
*-*-*freebsd*|*-*-*openbsd*)
|
||||
platform_win32=no
|
||||
CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE -DGC_FREEBSD_THREADS"
|
||||
libmono_cflags="-D_THREAD_SAFE"
|
||||
@@ -303,21 +248,9 @@ AC_ARG_WITH(gc, [ --with-gc=boehm,included,none],[gc=$with_gc],[gc=$gc_default]
|
||||
|
||||
# Enable support for fast thread-local storage
|
||||
# Some systems have broken support, so we allow to disable it.
|
||||
AC_ARG_WITH(tls, [ --with-tls=__thread,pthread select Thread Local Storage implementation],[],[with_tls=__thread])
|
||||
|
||||
# Kept for compatibility
|
||||
AC_ARG_WITH(nptl, [ --with-nptl=yes,no deprecated, use --with-tls instead],[],[with_nptl=default])
|
||||
|
||||
if test "x$with_nptl" != "xdefault"; then
|
||||
if test "x$with_nptl" = "xyes"; then
|
||||
AC_MSG_WARN([--with-nptl=yes is deprecated, use --with-tls=__thread option instead.])
|
||||
with_tls=__thread
|
||||
fi
|
||||
if test "x$with_nptl" = "xno"; then
|
||||
AC_MSG_WARN([--with-nptl=no is deprecated, use --with-tls=pthread option instead.])
|
||||
with_tls=pthread
|
||||
fi
|
||||
fi
|
||||
# This is misnamed: __thread support has no relation to NPTL,
|
||||
# but people already use it...
|
||||
AC_ARG_WITH(nptl, [ --with-nptl=yes,no enable/disable support for __thread support],[],[with_nptl=yes])
|
||||
|
||||
# Enable support for using sigaltstack for SIGSEGV and stack overflow handling
|
||||
# This does not work on some platforms (bug #55253)
|
||||
@@ -466,7 +399,6 @@ if test x$platform_win32 = xno; then
|
||||
AC_CHECK_FUNCS(getpwuid_r)
|
||||
AC_CHECK_FUNCS(getresuid)
|
||||
AC_CHECK_FUNCS(setresuid)
|
||||
AC_CHECK_FUNCS(kqueue)
|
||||
|
||||
dnl ******************************************************************
|
||||
dnl *** Check for large file support ***
|
||||
@@ -709,17 +641,7 @@ if test x$platform_win32 = xno; then
|
||||
dnl *****************************
|
||||
dnl *** Checks for libpthread ***
|
||||
dnl *****************************
|
||||
# on FreeBSD -STABLE, the pthreads functions all reside in libc_r
|
||||
# and libpthread does not exist
|
||||
#
|
||||
case "${host}" in
|
||||
*-*-*freebsd4*)
|
||||
AC_CHECK_LIB(pthread, main, LIBS="$LIBS -pthread")
|
||||
;;
|
||||
*)
|
||||
AC_CHECK_LIB(pthread, main, LIBS="$LIBS -lpthread")
|
||||
;;
|
||||
esac
|
||||
AC_CHECK_LIB(pthread, main, LIBS="$LIBS -lpthread")
|
||||
AC_CHECK_HEADERS(pthread.h)
|
||||
AC_CHECK_FUNCS(pthread_mutex_timedlock)
|
||||
AC_CHECK_FUNCS(pthread_getattr_np pthread_attr_get_np)
|
||||
@@ -740,7 +662,7 @@ if test x$platform_win32 = xno; then
|
||||
dnl *** Checks for working __thread ***
|
||||
dnl ***********************************
|
||||
AC_MSG_CHECKING(for working __thread)
|
||||
if test "x$with_tls" != "x__thread"; then
|
||||
if test "x$with_nptl" != "xyes"; then
|
||||
AC_MSG_RESULT(disabled)
|
||||
else
|
||||
AC_TRY_RUN([
|
||||
@@ -1032,9 +954,8 @@ ac_cv_c_socklen_t=yes
|
||||
])
|
||||
|
||||
AC_CHECK_FUNCS(trunc, , AC_MSG_CHECKING(for trunc in math.h)
|
||||
# Simply calling trunc (0.0) is no good since gcc will optimize the call away
|
||||
AC_TRY_LINK([#include <math.h>],
|
||||
[ static void *p = &trunc; ],
|
||||
[ trunc(0.0); ],
|
||||
[
|
||||
AC_DEFINE(HAVE_TRUNC)
|
||||
AC_MSG_RESULT(yes)
|
||||
@@ -1175,11 +1096,7 @@ case "$host" in
|
||||
JIT_SUPPORTED=no
|
||||
;;
|
||||
sparc*-*-*)
|
||||
if test "x$ac_cv_sizeof_void_p" = "x8"; then
|
||||
TARGET=SPARC64
|
||||
else
|
||||
TARGET=SPARC
|
||||
fi
|
||||
TARGET=SPARC;
|
||||
arch_target=sparc;
|
||||
JIT_SUPPORTED=yes
|
||||
ACCESS_UNALIGNED="no"
|
||||
@@ -1267,14 +1184,6 @@ case "$host" in
|
||||
LIBC="libc.so.12"
|
||||
INTL="libintl.so.0"
|
||||
;;
|
||||
*-*-*freebsd*)
|
||||
LIBC="libc.so"
|
||||
INTL="libintl.so"
|
||||
;;
|
||||
*-*-*openbsd*)
|
||||
LIBC="libc.so"
|
||||
INTL="libintl.so"
|
||||
;;
|
||||
esac
|
||||
AC_SUBST(libsuffix)
|
||||
|
||||
@@ -1318,7 +1227,6 @@ AM_CONDITIONAL(INSTALL_2_0, test x$PREVIEW = xyes)
|
||||
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)
|
||||
AM_CONDITIONAL(SPARC64, test x$TARGET = xSPARC64)
|
||||
AM_CONDITIONAL(X86, test x$TARGET = xX86)
|
||||
AM_CONDITIONAL(AMD64, test x$TARGET = xAMD64)
|
||||
AM_CONDITIONAL(ALPHA, test x$TARGET = xALPHA)
|
||||
@@ -1391,7 +1299,7 @@ echo "
|
||||
|
||||
GC: $gc
|
||||
ICU: $enable_icu
|
||||
TLS: $with_tls
|
||||
__thread: $with_nptl
|
||||
SIGALTSTACK: $with_sigaltstack
|
||||
Engine: $jit_status
|
||||
2.0 Alpha: $PREVIEW
|
||||
|
||||
@@ -0,0 +1,246 @@
|
||||
System.Object
|
||||
System.Exception
|
||||
System.ValueType
|
||||
System.Delegate
|
||||
System.MulticastDelegate
|
||||
System.Enum
|
||||
System.Activator
|
||||
System.ArgIterator
|
||||
System.__ComObject
|
||||
System.TypedReference
|
||||
System.Security.AllowPartiallyTrustedCallersAttribute
|
||||
System.Runtime.Serialization.Formatter
|
||||
System.Runtime.Serialization.FormatterConverter
|
||||
System.Runtime.Serialization.FormatterServices
|
||||
System.Runtime.Serialization.ObjectIDGenerator
|
||||
System.Runtime.Serialization.ObjectManager
|
||||
System.Reflection.ModuleResolveEventHandler
|
||||
System.Reflection.Pointer
|
||||
System.Globalization.CompareInfo
|
||||
System.Globalization.HebrewCalendar
|
||||
System.Globalization.HijriCalendar
|
||||
System.Globalization.JapaneseCalendar
|
||||
System.Globalization.KoreanCalendar
|
||||
System.Globalization.SortKey
|
||||
System.Globalization.StringInfo
|
||||
System.Globalization.TaiwanCalendar
|
||||
System.Globalization.TextElementEnumerator
|
||||
System.Globalization.TextInfo
|
||||
System.Globalization.ThaiBuddhistCalendar
|
||||
System.IO.IsolatedStorage.IsolatedStorageFile
|
||||
System.Reflection.Emit.MethodRental
|
||||
System.Runtime.CompilerServices.AccessedThroughPropertyAttribute
|
||||
System.Runtime.CompilerServices.CallConvCdecl
|
||||
System.Runtime.CompilerServices.CallConvStdcall
|
||||
System.Runtime.CompilerServices.CallConvThiscall
|
||||
System.Runtime.CompilerServices.CallConvFastcall
|
||||
System.Runtime.CompilerServices.CustomConstantAttribute
|
||||
System.Runtime.CompilerServices.DateTimeConstantAttribute
|
||||
System.Runtime.CompilerServices.DiscardableAttribute
|
||||
System.Runtime.CompilerServices.DecimalConstantAttribute
|
||||
System.Runtime.CompilerServices.CompilationRelaxationsAttribute
|
||||
System.Runtime.CompilerServices.CompilerGlobalScopeAttribute
|
||||
System.Runtime.CompilerServices.IDispatchConstantAttribute
|
||||
System.Runtime.CompilerServices.IsVolatile
|
||||
System.Runtime.CompilerServices.IUnknownConstantAttribute
|
||||
System.Runtime.CompilerServices.RequiredAttributeAttribute
|
||||
System.Runtime.InteropServices.ArrayWithOffset
|
||||
System.Runtime.InteropServices.DispIdAttribute
|
||||
System.Runtime.InteropServices.ClassInterfaceType
|
||||
System.Runtime.InteropServices.ClassInterfaceAttribute
|
||||
System.Runtime.InteropServices.ComVisibleAttribute
|
||||
System.Runtime.InteropServices.LCIDConversionAttribute
|
||||
System.Runtime.InteropServices.ComRegisterFunctionAttribute
|
||||
System.Runtime.InteropServices.ComUnregisterFunctionAttribute
|
||||
System.Runtime.InteropServices.ProgIdAttribute
|
||||
System.Runtime.InteropServices.ImportedFromTypeLibAttribute
|
||||
System.Runtime.InteropServices.IDispatchImplType
|
||||
System.Runtime.InteropServices.IDispatchImplAttribute
|
||||
System.Runtime.InteropServices.ComSourceInterfacesAttribute
|
||||
System.Runtime.InteropServices.ComConversionLossAttribute
|
||||
System.Runtime.InteropServices.TypeLibTypeFlags
|
||||
System.Runtime.InteropServices.TypeLibFuncFlags
|
||||
System.Runtime.InteropServices.TypeLibVarFlags
|
||||
System.Runtime.InteropServices.TypeLibTypeAttribute
|
||||
System.Runtime.InteropServices.TypeLibFuncAttribute
|
||||
System.Runtime.InteropServices.TypeLibVarAttribute
|
||||
System.Runtime.InteropServices.ComImportAttribute
|
||||
System.Runtime.InteropServices.PreserveSigAttribute
|
||||
System.Runtime.InteropServices.ComAliasNameAttribute
|
||||
System.Runtime.InteropServices.AutomationProxyAttribute
|
||||
System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute
|
||||
System.Runtime.InteropServices.CoClassAttribute
|
||||
System.Runtime.InteropServices.ComEventInterfaceAttribute
|
||||
System.Runtime.InteropServices.COMException
|
||||
System.Runtime.InteropServices.ComMemberType
|
||||
System.Runtime.InteropServices.CurrencyWrapper
|
||||
System.Runtime.InteropServices.DispatchWrapper
|
||||
System.Runtime.InteropServices.ErrorWrapper
|
||||
System.Runtime.InteropServices.ExtensibleClassFactory
|
||||
System.Runtime.InteropServices.HandleRef
|
||||
System.Runtime.InteropServices.InvalidComObjectException
|
||||
System.Runtime.InteropServices.InvalidOleVariantTypeException
|
||||
System.Runtime.InteropServices.TypeLibImporterFlags
|
||||
System.Runtime.InteropServices.ExporterEventKind
|
||||
System.Runtime.InteropServices.ITypeLibExporterNotifySink
|
||||
System.Runtime.InteropServices.ITypeLibConverter
|
||||
System.Runtime.InteropServices.MarshalDirectiveException
|
||||
System.Runtime.InteropServices.ObjectCreationDelegate
|
||||
System.Runtime.InteropServices.RuntimeEnvironment
|
||||
System.Runtime.InteropServices.RegistrationServices
|
||||
System.Runtime.InteropServices.SafeArrayRankMismatchException
|
||||
System.Runtime.InteropServices.SafeArrayTypeMismatchException
|
||||
System.Runtime.InteropServices.SEHException
|
||||
System.Runtime.InteropServices.TypeLibConverter
|
||||
System.Runtime.InteropServices.BIND_OPTS
|
||||
System.Runtime.InteropServices.UCOMIBindCtx
|
||||
System.Runtime.InteropServices.UCOMIConnectionPointContainer
|
||||
System.Runtime.InteropServices.UCOMIConnectionPoint
|
||||
System.Runtime.InteropServices.UCOMIEnumMoniker
|
||||
System.Runtime.InteropServices.CONNECTDATA
|
||||
System.Runtime.InteropServices.UCOMIEnumConnections
|
||||
System.Runtime.InteropServices.UCOMIEnumConnectionPoints
|
||||
System.Runtime.InteropServices.UCOMIEnumString
|
||||
System.Runtime.InteropServices.UCOMIEnumVARIANT
|
||||
System.Runtime.InteropServices.FILETIME
|
||||
System.Runtime.InteropServices.UCOMIMoniker
|
||||
System.Runtime.InteropServices.UCOMIPersistFile
|
||||
System.Runtime.InteropServices.UCOMIRunningObjectTable
|
||||
System.Runtime.InteropServices.STATSTG
|
||||
System.Runtime.InteropServices.UCOMIStream
|
||||
System.Runtime.InteropServices.DESCKIND
|
||||
System.Runtime.InteropServices.BINDPTR
|
||||
System.Runtime.InteropServices.UCOMITypeComp
|
||||
System.Runtime.InteropServices.TYPEKIND
|
||||
System.Runtime.InteropServices.TYPEFLAGS
|
||||
System.Runtime.InteropServices.IMPLTYPEFLAGS
|
||||
System.Runtime.InteropServices.TYPEATTR
|
||||
System.Runtime.InteropServices.FUNCDESC
|
||||
System.Runtime.InteropServices.IDLFLAG
|
||||
System.Runtime.InteropServices.IDLDESC
|
||||
System.Runtime.InteropServices.PARAMFLAG
|
||||
System.Runtime.InteropServices.PARAMDESC
|
||||
System.Runtime.InteropServices.TYPEDESC
|
||||
System.Runtime.InteropServices.ELEMDESC
|
||||
System.Runtime.InteropServices.VARDESC
|
||||
System.Runtime.InteropServices.DISPPARAMS
|
||||
System.Runtime.InteropServices.EXCEPINFO
|
||||
System.Runtime.InteropServices.FUNCKIND
|
||||
System.Runtime.InteropServices.INVOKEKIND
|
||||
System.Runtime.InteropServices.CALLCONV
|
||||
System.Runtime.InteropServices.FUNCFLAGS
|
||||
System.Runtime.InteropServices.VARFLAGS
|
||||
System.Runtime.InteropServices.UCOMITypeInfo
|
||||
System.Runtime.InteropServices.SYSKIND
|
||||
System.Runtime.InteropServices.LIBFLAGS
|
||||
System.Runtime.InteropServices.TYPELIBATTR
|
||||
System.Runtime.InteropServices.UCOMITypeLib
|
||||
System.Runtime.InteropServices.UnknownWrapper
|
||||
System.Runtime.Remoting.IObjectHandle
|
||||
System.Runtime.Remoting.IRemotingTypeInfo
|
||||
System.Runtime.Remoting.IChannelInfo
|
||||
System.Runtime.Remoting.IEnvoyInfo
|
||||
System.Runtime.Remoting.RemotingConfiguration
|
||||
System.Runtime.Remoting.TypeEntry
|
||||
System.Runtime.Remoting.ActivatedClientTypeEntry
|
||||
System.Runtime.Remoting.ActivatedServiceTypeEntry
|
||||
System.Runtime.Remoting.WellKnownClientTypeEntry
|
||||
System.Runtime.Remoting.WellKnownServiceTypeEntry
|
||||
System.Runtime.Remoting.RemotingException
|
||||
System.Runtime.Remoting.ServerException
|
||||
System.Runtime.Remoting.RemotingTimeoutException
|
||||
System.Runtime.Remoting.RemotingServices
|
||||
System.Runtime.Remoting.InternalRemotingServices
|
||||
System.Runtime.Remoting.SoapServices
|
||||
System.Runtime.Remoting.Activation.UrlAttribute
|
||||
System.Runtime.Remoting.Messaging.IMessageSink
|
||||
System.Runtime.Remoting.Messaging.AsyncResult
|
||||
System.Runtime.Remoting.Messaging.CallContext
|
||||
System.Runtime.Remoting.Messaging.ILogicalThreadAffinative
|
||||
System.Runtime.Remoting.Messaging.InternalMessageWrapper
|
||||
System.Runtime.Remoting.Messaging.IMethodCallMessage
|
||||
System.Runtime.Remoting.Messaging.MethodCallMessageWrapper
|
||||
System.Runtime.Remoting.Messaging.HeaderHandler
|
||||
System.Runtime.Remoting.Messaging.IMessageCtrl
|
||||
System.Runtime.Remoting.Messaging.IRemotingFormatter
|
||||
System.Runtime.Remoting.Messaging.ReturnMessage
|
||||
System.Runtime.Remoting.Messaging.MethodCall
|
||||
System.Runtime.Remoting.Messaging.ConstructionCall
|
||||
System.Runtime.Remoting.Messaging.MethodResponse
|
||||
System.Runtime.Remoting.Messaging.ConstructionResponse
|
||||
System.Runtime.Remoting.Messaging.MethodReturnMessageWrapper
|
||||
System.Runtime.Remoting.Messaging.OneWayAttribute
|
||||
System.Runtime.Remoting.Messaging.MessageSurrogateFilter
|
||||
System.Runtime.Remoting.Messaging.RemotingSurrogateSelector
|
||||
System.Runtime.Remoting.Contexts.CrossContextDelegate
|
||||
System.Runtime.Remoting.Contexts.ContextProperty
|
||||
System.Runtime.Remoting.Contexts.IContextPropertyActivator
|
||||
System.Runtime.Remoting.Contexts.IContributeClientContextSink
|
||||
System.Runtime.Remoting.Contexts.IContributeDynamicSink
|
||||
System.Runtime.Remoting.Contexts.IContributeEnvoySink
|
||||
System.Runtime.Remoting.Contexts.IContributeObjectSink
|
||||
System.Runtime.Remoting.Contexts.IContributeServerContextSink
|
||||
System.Runtime.Serialization.Formatters.InternalRM
|
||||
System.Runtime.Serialization.Formatters.InternalST
|
||||
System.Runtime.Serialization.Formatters.SoapMessage
|
||||
System.Runtime.Serialization.Formatters.SoapFault
|
||||
System.Runtime.Serialization.Formatters.ServerFault
|
||||
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
|
||||
System.Security.Cryptography.CryptoConfig
|
||||
System.Security.Cryptography.KeyedHashAlgorithm
|
||||
System.Security.Cryptography.HMACSHA1
|
||||
System.Security.Cryptography.MACTripleDES
|
||||
System.Security.Cryptography.MaskGenerationMethod
|
||||
System.Security.Cryptography.PasswordDeriveBytes
|
||||
System.Security.Cryptography.PKCS1MaskGenerationMethod
|
||||
System.Security.Cryptography.RC2
|
||||
System.Security.Cryptography.RC2CryptoServiceProvider
|
||||
System.Security.Cryptography.RSACryptoServiceProvider
|
||||
System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter
|
||||
System.Security.Cryptography.RSAOAEPKeyExchangeFormatter
|
||||
System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter
|
||||
System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter
|
||||
System.Security.Cryptography.RSAPKCS1SignatureDeformatter
|
||||
System.Security.Cryptography.RSAPKCS1SignatureFormatter
|
||||
System.Security.Cryptography.SHA1Managed
|
||||
System.Security.Cryptography.TripleDES
|
||||
System.Security.Cryptography.TripleDESCryptoServiceProvider
|
||||
System.Security.Permissions.EnvironmentPermission
|
||||
System.Security.Permissions.FileDialogPermission
|
||||
System.Security.Permissions.IsolatedStorageFilePermission
|
||||
System.Security.Permissions.PrincipalPermissionAttribute
|
||||
System.Security.Permissions.SecurityPermissionAttribute
|
||||
System.Security.Permissions.PublisherIdentityPermissionAttribute
|
||||
System.Security.Permissions.PublisherIdentityPermission
|
||||
System.Security.Permissions.ReflectionPermission
|
||||
System.Security.Permissions.RegistryPermission
|
||||
System.Security.Permissions.PrincipalPermission
|
||||
System.Security.Permissions.SiteIdentityPermission
|
||||
System.Security.Permissions.StrongNameIdentityPermission
|
||||
System.Security.Permissions.StrongNamePublicKeyBlob
|
||||
System.Security.Permissions.UIPermission
|
||||
System.Security.Permissions.UrlIdentityPermission
|
||||
System.Security.Permissions.ZoneIdentityPermission
|
||||
System.Security.Policy.ApplicationDirectory
|
||||
System.Security.Policy.ApplicationDirectoryMembershipCondition
|
||||
System.Security.Policy.FirstMatchCodeGroup
|
||||
System.Security.Policy.Hash
|
||||
System.Security.Policy.HashMembershipCondition
|
||||
System.Security.Policy.NetCodeGroup
|
||||
System.Security.Policy.PermissionRequestEvidence
|
||||
System.Security.Policy.Publisher
|
||||
System.Security.Policy.PublisherMembershipCondition
|
||||
System.Security.Policy.Site
|
||||
System.Security.Policy.SiteMembershipCondition
|
||||
System.Security.Policy.StrongName
|
||||
System.Security.Policy.StrongNameMembershipCondition
|
||||
System.Security.Policy.UnionCodeGroup
|
||||
System.Security.Policy.Url
|
||||
System.Security.Policy.UrlMembershipCondition
|
||||
System.Security.Policy.Zone
|
||||
System.Security.Policy.ZoneMembershipCondition
|
||||
System.Security.Principal.WindowsIdentity
|
||||
System.Security.Principal.WindowsImpersonationContext
|
||||
System.Security.Principal.WindowsPrincipal
|
||||
System.Threading.CompressedStack
|
||||
|
||||
+14
-48
@@ -24,17 +24,20 @@ convention is that assemblies must also be placed in a separate
|
||||
directory for being accessed to the compiler. This is done with the
|
||||
-package directive to gacutil.
|
||||
.PP
|
||||
The tool allows for installation, removal, and listing of the
|
||||
The tool allows for installationl, removal, and listing of the
|
||||
contents of the assembly cache.
|
||||
.PP
|
||||
The GAC is relative to the Mono installation prefix:
|
||||
mono_prefix/lib/mono.
|
||||
.SH FLAGS
|
||||
The "-user" flag enables you to install/remove the assembly into the
|
||||
user's assembly cache, as opposed to the global one.
|
||||
.PP
|
||||
.SH COMMANDS
|
||||
.I -i <assembly_path> [-check_refs] [-package NAME] [-root ROOTDIR] [-gacdir GACDIR]
|
||||
.I "-i path_to_assembly" [-f] [-root ROOTDIR] [-package NAME]
|
||||
.Sp
|
||||
Installs an assembly into the global assembly cache. <assembly_path>
|
||||
is the name of the file that contains the assembly manifest
|
||||
The above installs the assembly into the GAC, use the -f flag to force
|
||||
an installation an overwrite anything in there.
|
||||
.Sp
|
||||
The -package option can be used to also create a directory in in
|
||||
prefix/lib/mono with the name NAME, and a symlink is created from
|
||||
@@ -44,32 +47,18 @@ developers can reference a set of libraries at once.
|
||||
The -root option is used by developers integrating this with automake
|
||||
tools or packaging tools that require a prefix directory to be
|
||||
specified. The root represents the "libdir" component of a prefix
|
||||
(typically prefix/lib).
|
||||
.Sp
|
||||
The -gacdir option is used to specify the GACs base directory. Once an
|
||||
assembly has been installed to a non standard gacdir the MONO_GAC_PATH
|
||||
environment variable must be used to access the assembly.
|
||||
.Sp
|
||||
The -check_refs option is used to ensure that the assembly being
|
||||
installed into the GAC does not reference any non strong named
|
||||
assemblies. Assemblies being installed to the GAC should not reference
|
||||
non strong named assemblies, however the is an optional check.
|
||||
(typically prefix/lib).
|
||||
.fi
|
||||
.PP
|
||||
.I "-l" [assembly_name] [-root ROOTDIR] [-gacdir GACDIR]
|
||||
.I "-l"
|
||||
.Sp
|
||||
Lists the contents of the global assembly cache. When the
|
||||
<assembly_name> parameter is specified only matching assemblies are
|
||||
listed.
|
||||
Lists the contents of the Global Assembly Cache
|
||||
.PP
|
||||
.I "-u" <assembly_display_name> [-package NAME] [-root ROOTDIR] [-gacdir GACDIR]
|
||||
.I "-u assembly_name [-root]"
|
||||
.Sp
|
||||
Uninstalls an assembly from the global assembly cache.
|
||||
<assembly_display_name> is the name of the assembly (partial or
|
||||
fully qualified) to remove from the global assembly cache. If a
|
||||
partial name is specified all matching assemblies will be
|
||||
uninstalled. As opposed to the install option that takes a filename,
|
||||
this takes as an argument the assembly name, which looks like this:
|
||||
The above removes the given assembly name from the Global Assembly
|
||||
Cache. As opposed to the install option that takes a filename, this
|
||||
takes as an argument the assembly name, which looks like this:
|
||||
.nf
|
||||
MyLibrary.Something, version=1.0.0.0, publicKeyToken=xxxx,culture=neutral
|
||||
.fi
|
||||
@@ -80,29 +69,6 @@ to quote them.
|
||||
The removal performs a greedy removal, if you only specifiy one
|
||||
component like, "MyLibrary.Something", it will remove all versions of
|
||||
the library.
|
||||
.Sp
|
||||
.I "-us" <assembly_path> [-package NAME] [-root ROOTDIR] [-gacdir GACDIR]
|
||||
Uninstalls an assembly using the specifed assemblies full name.
|
||||
<assembly path> is the path to an assembly. The full assembly name
|
||||
is retrieved from the specified assembly if there is an assembly in
|
||||
the GAC with a matching name, it is removed. Unlike the -u option this
|
||||
option takes a file name, like this:
|
||||
.nf
|
||||
Example: -us myDll.dll
|
||||
.fi
|
||||
.Sp
|
||||
.I "-ul" <assembly_list_file> [-package NAME] [-root ROOTDIR] [-gacdir GACDIR]
|
||||
Uninstalls one or more assemblies from the global assembly cache.
|
||||
<assembly_list_file> is the path to a test file containing a list of
|
||||
assembly names on separate lines.
|
||||
.nf
|
||||
Example -ul assembly_list.txt
|
||||
.fi
|
||||
.nf
|
||||
assembly_list.txt contents:
|
||||
assembly1,Version=1.0.0.0,Culture=en,PublicKeyToken=0123456789abcdef
|
||||
assembly2,Version=2.0.0.0,Culture=en,PublicKeyToken=0123456789abcdef
|
||||
.fi
|
||||
.SH FILES
|
||||
On Unix assemblies are loaded from the installation lib directory. If you set
|
||||
`prefix' to /usr, the assemblies will be located in /usr/lib. On
|
||||
|
||||
@@ -1,3 +1,8 @@
|
||||
2004-10-05 Anirban Bhattacharjee <[email protected]>
|
||||
* Interaction.cs:
|
||||
* Strings.cs :
|
||||
Few important fixes
|
||||
|
||||
2004-07-22 Jambunathan K <[email protected]>
|
||||
|
||||
* Constants.cs: Fixed definitions of vbCr, vbLf, vbCrLf and
|
||||
|
||||
@@ -352,7 +352,7 @@ namespace Microsoft.VisualBasic {
|
||||
string [] args = Environment.GetCommandLineArgs ();
|
||||
|
||||
if (args != null && args.Length > 1) {
|
||||
return string.Join (" ", args, 2, args.Length - 1);
|
||||
return string.Join (" ", args, 1, args.Length - 1);
|
||||
} else {
|
||||
return "";
|
||||
}
|
||||
|
||||
@@ -401,7 +401,21 @@ namespace Microsoft.VisualBasic
|
||||
}
|
||||
break;
|
||||
default:
|
||||
returnstr=Convert.ToDouble(expression).ToString (style);
|
||||
if (style.IndexOf("X") != -1
|
||||
|| style.IndexOf("x") != -1 ) {
|
||||
returnstr = Microsoft.VisualBasic.Conversion.Hex(Convert.ToInt64(expression));
|
||||
}
|
||||
else
|
||||
try
|
||||
{
|
||||
returnstr=Convert.ToDouble(expression).ToString (style);
|
||||
}
|
||||
catch (Exception ex){
|
||||
style = "0" + style;
|
||||
returnstr=Convert.ToDouble(expression).ToString (style);
|
||||
}
|
||||
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
@@ -694,6 +708,7 @@ namespace Microsoft.VisualBasic
|
||||
return InStr(1, String1, String2, Compare);
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Returns an integer specifying the start position of the first occurrence of one string within another.
|
||||
/// </summary>
|
||||
@@ -826,17 +841,22 @@ namespace Microsoft.VisualBasic
|
||||
[DefaultValue(" ")]
|
||||
string Delimiter)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (SourceArray == null)
|
||||
throw new ArgumentException("Argument 'SourceArray' can not be null.", "SourceArray");
|
||||
if (SourceArray.Rank > 1)
|
||||
throw new ArgumentException("Argument 'SourceArray' can have only one dimension.", "SourceArray");
|
||||
|
||||
if (SourceArray == null)
|
||||
throw new ArgumentException("Argument 'SourceArray' can not be null.", "SourceArray");
|
||||
if (SourceArray.Rank > 1)
|
||||
throw new ArgumentException("Argument 'SourceArray' can have only one dimension.", "SourceArray");
|
||||
string[] dest;
|
||||
dest = new string[SourceArray.Length];
|
||||
|
||||
string[] dest;
|
||||
dest = new string[SourceArray.Length];
|
||||
|
||||
SourceArray.CopyTo(dest, 0);
|
||||
return string.Join(Delimiter, dest);
|
||||
SourceArray.CopyTo(dest, 0);
|
||||
return string.Join(Delimiter, dest);
|
||||
}
|
||||
catch (System.InvalidCastException ie){
|
||||
throw new System.ArgumentException("Invalid argument");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -854,8 +874,8 @@ namespace Microsoft.VisualBasic
|
||||
/// <param name="Value">Required. Any valid String or Char expression.</param>
|
||||
public static string LCase(string Value)
|
||||
{
|
||||
if ((Value == null) || (Value.Length == 0))
|
||||
return String.Empty; // VB.net does this.
|
||||
if ((Value == null) || (Value.Length == 0))
|
||||
return Value; // comparing nunit test results say this is an exception to the return String.Empty rule
|
||||
|
||||
return Value.ToLower();
|
||||
}
|
||||
@@ -865,16 +885,18 @@ namespace Microsoft.VisualBasic
|
||||
/// Returns a string containing a specified number of characters from the left side of a string.
|
||||
/// </summary>
|
||||
/// <param name="Str">Required. String expression from which the leftmost characters are returned.</param>
|
||||
/// <param name="Length">Required. Integer expression. Numeric expression indicating how many characters to return. If 0, a zero-length string ("") is returned. If greater than or equal to the number of characters in Str, the entire string is returned.</param>
|
||||
public static string Left(string Str,
|
||||
int Length)
|
||||
/// <param name="Length">Required. Integer expression. Numeric expression indicating how many characters to return.
|
||||
/// If 0, a zero-length string ("") is returned. If greater than or equal to the number of characters in Str,
|
||||
/// the entire string is returned.</param>
|
||||
public static string Left(string Str, int Length)
|
||||
{
|
||||
if (Length < 0)
|
||||
throw new ArgumentException("Argument 'Length' must be non-negative.", "Length");
|
||||
if ((Str == null) || (Str.Length == 0))
|
||||
if ((Str == null) || (Str.Length == 0) || Length == 0)
|
||||
return String.Empty; // VB.net does this.
|
||||
|
||||
return Str.Substring(0, Length);
|
||||
if (Length < Str.Length)
|
||||
return Str.Substring(0, Length);
|
||||
return Str;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -1202,16 +1224,16 @@ namespace Microsoft.VisualBasic
|
||||
/// </summary>
|
||||
/// <param name="Source">Required. String expression. Name of string variable.</param>
|
||||
/// <param name="Length">Required. Integer expression. Length of returned string.</param>
|
||||
public static string RSet(string Source,
|
||||
int Length)
|
||||
public static string RSet(string Source, int Length)
|
||||
{
|
||||
|
||||
if (Source == null)
|
||||
Source = String.Empty;
|
||||
if (Length < 0)
|
||||
throw new ArgumentOutOfRangeException("Length", "Length must be non-negative.");
|
||||
|
||||
return Source.PadLeft(Length);
|
||||
if (Length > Source.Length)
|
||||
return Source.PadLeft(Length);
|
||||
return Source.Substring(0, Length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -1235,7 +1257,7 @@ namespace Microsoft.VisualBasic
|
||||
/// <param name="Compare">Optional. Numeric value indicating the comparison to use when evaluating substrings. See Settings for values.</param>
|
||||
public static string[] Split(string Expression,
|
||||
[Optional]
|
||||
[DefaultValue(" ")]
|
||||
[DefaultValue("")]
|
||||
string Delimiter,
|
||||
[Optional]
|
||||
[DefaultValue(-1)]
|
||||
@@ -1245,30 +1267,37 @@ namespace Microsoft.VisualBasic
|
||||
[DefaultValue(CompareMethod.Binary)]
|
||||
CompareMethod Compare)
|
||||
{
|
||||
|
||||
|
||||
if (Expression == null)
|
||||
return new string[1];
|
||||
|
||||
if ((Delimiter == null) || (Delimiter.Length == 0))
|
||||
{
|
||||
if ((Delimiter == null) || (Delimiter.Length == 0)) {
|
||||
string [] ret = new string[1];
|
||||
ret[0] = Expression;
|
||||
return ret;
|
||||
}
|
||||
if (Limit == 0)
|
||||
Limit = 1;
|
||||
|
||||
if (Limit < -1)
|
||||
else if (Limit < -1)
|
||||
throw new OverflowException("Arithmetic operation resulted in an overflow.");
|
||||
switch (Compare)
|
||||
{
|
||||
case CompareMethod.Binary:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1), Limit);
|
||||
case CompareMethod.Text:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1), Limit);
|
||||
default:
|
||||
throw new System.ArgumentException("Argument 'Compare' must be CompareMethod.Binary or CompareMethod.Text.", "Compare");
|
||||
|
||||
if (Limit != -1) {
|
||||
switch (Compare){
|
||||
case CompareMethod.Binary:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1), Limit);
|
||||
case CompareMethod.Text:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1), Limit);
|
||||
default:
|
||||
throw new System.ArgumentException("Argument 'Compare' must be CompareMethod.Binary or CompareMethod.Text.", "Compare");
|
||||
}
|
||||
} else {
|
||||
switch (Compare) {
|
||||
case CompareMethod.Binary:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1));
|
||||
case CompareMethod.Text:
|
||||
return Expression.Split(Delimiter.ToCharArray(0, 1));
|
||||
default:
|
||||
throw new System.ArgumentException("Argument 'Compare' must be CompareMethod.Binary or CompareMethod.Text.", "Compare");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,3 +1,7 @@
|
||||
2004-10-05 Sebastien Pouliot <[email protected]>
|
||||
|
||||
* SslClientStream.cs: Changed InputBuffer to internal (was protected).
|
||||
|
||||
2004-10-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpsClientStream.cs: the .ctor receives a pre-read buffer now.
|
||||
|
||||
@@ -125,7 +125,8 @@ namespace Mono.Security.Protocol.Tls
|
||||
set { throw new NotSupportedException(); }
|
||||
}
|
||||
|
||||
protected Stream InputBuffer {
|
||||
// required by HttpsClientStream for proxy support
|
||||
internal Stream InputBuffer {
|
||||
get { return inputBuffer; }
|
||||
}
|
||||
#endregion
|
||||
|
||||
@@ -1,3 +1,15 @@
|
||||
2004-10-08 Atsushi Enomoto <[email protected]>
|
||||
|
||||
* DataSet.cs : Yesterday's fix was different and broke the build :(
|
||||
|
||||
2004-10-07 Atsushi Enomoto <[email protected]>
|
||||
|
||||
* DataSet.cs :
|
||||
- When AllowDBNull is false on attribute DataColumn, its schema
|
||||
should contain use="required". This fixes bug #66792.
|
||||
- If MaxLength is set on attribute DataColumn, the mapped schema
|
||||
type should contain maxLength facet. This fixes bug #66793.
|
||||
|
||||
2004-10-04 Atsushi Enomoto <[email protected]>
|
||||
|
||||
* DataSet.cs : For a row, when a relation is not nested, then it is
|
||||
|
||||
@@ -1767,8 +1767,20 @@ namespace System.Data {
|
||||
// FIXME: Handle prefix mapping correctly.
|
||||
schemaToAdd.Namespaces.Add (prefix, col.Namespace);
|
||||
}
|
||||
att.SchemaTypeName = MapType (col.DataType);
|
||||
if (!col.AllowDBNull)
|
||||
att.Use = XmlSchemaUse.Required;
|
||||
|
||||
if (col.MaxLength > -1)
|
||||
att.SchemaType = GetTableSimpleType (doc, col);
|
||||
else
|
||||
att.SchemaTypeName = MapType (col.DataType);
|
||||
// FIXME: what happens if extended properties are set on attribute columns??
|
||||
if (!col.AllowDBNull)
|
||||
att.Use = XmlSchemaUse.Required;
|
||||
if (col.MaxLength > -1)
|
||||
att.SchemaType = GetTableSimpleType (doc, col);
|
||||
else
|
||||
att.SchemaTypeName = MapType (col.DataType);
|
||||
schemaAttributes.Add (att);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
//
|
||||
// System.Web.Compilation.BuildProviderResultFlags.cs
|
||||
//
|
||||
// Authors:
|
||||
// Duncan Mak ([email protected])
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining
|
||||
// a copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to
|
||||
// permit persons to whom the Software is furnished to do so, subject to
|
||||
// the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
|
||||
using System.Resources;
|
||||
|
||||
#if NET_2_0
|
||||
namespace System.Web.Compilation
|
||||
{
|
||||
[Serializable, Flags]
|
||||
public enum BuildProviderResultFlags
|
||||
{
|
||||
Default = 0,
|
||||
ShutdownAppDomainOnChange = 1
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,42 +0,0 @@
|
||||
//
|
||||
// System.Web.Compilation.IImplicitResourceProvider.cs
|
||||
//
|
||||
// Authors:
|
||||
// Duncan Mak ([email protected])
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining
|
||||
// a copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to
|
||||
// permit persons to whom the Software is furnished to do so, subject to
|
||||
// the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
|
||||
#if NET_2_0
|
||||
|
||||
using System.Collections;
|
||||
using System.Globalization;
|
||||
|
||||
namespace System.Web.Compilation
|
||||
{
|
||||
public interface IImplicitResourceProvider
|
||||
{
|
||||
object GetObject (ImplicitResourceKey key, CultureInfo culture);
|
||||
ICollection GetResources (string keyPrefix);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,39 +0,0 @@
|
||||
//
|
||||
// System.Web.Compilation.IResourceProvider.cs
|
||||
//
|
||||
// Authors:
|
||||
// Duncan Mak ([email protected])
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining
|
||||
// a copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to
|
||||
// permit persons to whom the Software is furnished to do so, subject to
|
||||
// the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
|
||||
using System.Resources;
|
||||
|
||||
#if NET_2_0
|
||||
namespace System.Web.Compilation
|
||||
{
|
||||
public interface IResourceProvider
|
||||
{
|
||||
IResourceReader ResourceReader { get; }
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,43 +0,0 @@
|
||||
//
|
||||
// System.Web.Compilation.IImplicitResourceProvider.cs
|
||||
//
|
||||
// Authors:
|
||||
// Duncan Mak ([email protected])
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining
|
||||
// a copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to
|
||||
// permit persons to whom the Software is furnished to do so, subject to
|
||||
// the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
||||
//
|
||||
|
||||
#if NET_2_0
|
||||
namespace System.Web.Compilation
|
||||
{
|
||||
public class ImplicitResourceKey
|
||||
{
|
||||
public ImplicitResourceKey ()
|
||||
{
|
||||
}
|
||||
|
||||
public string Filter;
|
||||
public string KeyPrefix;
|
||||
public string Property;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1,3 +1,8 @@
|
||||
2004-10-06 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* TraceHandler.cs: error code is 403 and the message different when
|
||||
trace is enabled but not for remote clients.
|
||||
|
||||
2004-07-02 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* TraceHandler.cs: check that trace is enabled or throw.
|
||||
|
||||
@@ -44,11 +44,21 @@ namespace System.Web.Handlers
|
||||
#endif
|
||||
class TraceNotAvailableException : HttpException
|
||||
{
|
||||
public TraceNotAvailableException () :
|
||||
base ("Trace Error") {}
|
||||
bool notLocal;
|
||||
|
||||
public TraceNotAvailableException (bool notLocal) :
|
||||
base (notLocal ? 403 : 500, "Trace Error")
|
||||
{
|
||||
this.notLocal = notLocal;
|
||||
}
|
||||
|
||||
internal override string Description {
|
||||
get { return "Trace.axd is not enabled in the configuration file for this application."; }
|
||||
get {
|
||||
if (notLocal)
|
||||
return "Trace is not enabled for remote clients.";
|
||||
|
||||
return "Trace.axd is not enabled in the configuration file for this application.";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -58,9 +68,8 @@ namespace System.Web.Handlers
|
||||
{
|
||||
TraceManager manager = HttpRuntime.TraceManager;
|
||||
|
||||
if (!manager.Enabled || manager.LocalOnly && !context.Request.IsLocal) {
|
||||
throw new TraceNotAvailableException ();
|
||||
}
|
||||
if (!manager.Enabled || manager.LocalOnly && !context.Request.IsLocal)
|
||||
throw new TraceNotAvailableException (manager.Enabled);
|
||||
|
||||
HtmlTextWriter output = new HtmlTextWriter (context.Response.Output);
|
||||
|
||||
|
||||
@@ -1,3 +1,7 @@
|
||||
2004-10-06 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* SessionStateModule.cs: use SetCurrentExePath instead of SetFilePath.
|
||||
|
||||
2004-09-09 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpSessionState.cs: don't share static session objects declared in
|
||||
|
||||
@@ -109,7 +109,7 @@ namespace System.Web.SessionState
|
||||
if (id == null)
|
||||
return;
|
||||
|
||||
context.Request.SetFilePath (UrlUtils.RemoveSessionId (base_path,
|
||||
context.Request.SetCurrentExePath (UrlUtils.RemoveSessionId (base_path,
|
||||
context.Request.FilePath));
|
||||
context.Request.SetHeader (HeaderName, id);
|
||||
}
|
||||
|
||||
@@ -1,3 +1,14 @@
|
||||
2004-10-06 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpRequest.cs: CurrentExecutionFilePath is the one that
|
||||
changes when Transfer or Execute are used, not FilePath.
|
||||
|
||||
* HttpServerUtility.cs: moved form saving/restoring from
|
||||
Transfer to Execute, as it's needed there too. the query string is
|
||||
correctly set now. Fixes bug #67388.
|
||||
|
||||
* HttpContext.cs: use SetCurrentExePath instead of SetFilePath.
|
||||
|
||||
2004-10-03 Ben Maurer <[email protected]>
|
||||
|
||||
* HttpResponse.cs: use UtcNow
|
||||
|
||||
@@ -403,7 +403,7 @@ namespace System.Web
|
||||
throw new HttpException (404, "The virtual path '" + path +
|
||||
"' maps to another application.");
|
||||
|
||||
Request.SetFilePath (path);
|
||||
Request.SetCurrentExePath (path);
|
||||
Request.QueryStringRaw = query;
|
||||
}
|
||||
|
||||
|
||||
@@ -88,6 +88,7 @@ namespace System.Web {
|
||||
Stream userFilter;
|
||||
HttpRequestStream requestFilter;
|
||||
string clientTarget;
|
||||
string currentExePath;
|
||||
#if NET_1_1
|
||||
bool validateCookies;
|
||||
bool validateForm;
|
||||
@@ -503,6 +504,9 @@ namespace System.Web {
|
||||
|
||||
public string CurrentExecutionFilePath {
|
||||
get {
|
||||
if (currentExePath != null)
|
||||
return currentExePath;
|
||||
|
||||
return FilePath;
|
||||
}
|
||||
}
|
||||
@@ -1139,9 +1143,9 @@ namespace System.Web {
|
||||
}
|
||||
#endif
|
||||
|
||||
internal void SetFilePath (string filePath)
|
||||
internal void SetCurrentExePath (string filePath)
|
||||
{
|
||||
_sFilePath = filePath;
|
||||
currentExePath = filePath;
|
||||
_sRequestRootVirtualDir = null;
|
||||
baseVirtualDir = null;
|
||||
}
|
||||
|
||||
@@ -192,19 +192,26 @@ namespace System.Web
|
||||
} else {
|
||||
query = "";
|
||||
}
|
||||
|
||||
string filePath = _Context.Request.MapPath (path);
|
||||
|
||||
HttpRequest request = _Context.Request;
|
||||
HttpResponse response = _Context.Response;
|
||||
|
||||
string oldQuery = request.QueryStringRaw;
|
||||
request.QueryStringRaw = query;
|
||||
|
||||
HttpValueCollection oldForm = null;
|
||||
if (!preserveQuery) {
|
||||
oldForm = _Context.Request.Form as HttpValueCollection;
|
||||
_Context.Request.SetForm (new HttpValueCollection ());
|
||||
}
|
||||
|
||||
string filePath = _Context.Request.MapPath (path);
|
||||
TextWriter output = writer;
|
||||
if (output == null)
|
||||
output = response.Output;
|
||||
|
||||
HttpRequest request = _Context.Request;
|
||||
string oldFilePath = request.FilePath;
|
||||
request.SetFilePath (UrlUtils.Combine (_Context.Request.BaseVirtualDir, path));
|
||||
string oldQuery = request.QueryStringRaw;
|
||||
|
||||
if (!preserveQuery) request.QueryStringRaw = query;
|
||||
request.SetCurrentExePath (UrlUtils.Combine (_Context.Request.BaseVirtualDir, path));
|
||||
IHttpHandler handler = _Context.ApplicationInstance.CreateHttpHandler (_Context,
|
||||
request.RequestType,
|
||||
path,
|
||||
@@ -221,9 +228,11 @@ namespace System.Web
|
||||
asyncHandler.EndProcessRequest (ar);
|
||||
}
|
||||
} finally {
|
||||
request.SetFilePath (oldFilePath);
|
||||
request.SetCurrentExePath (oldFilePath);
|
||||
request.QueryStringRaw = oldQuery;
|
||||
response.SetTextWriter (previous);
|
||||
if (!preserveQuery)
|
||||
_Context.Request.SetForm (oldForm);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -324,16 +333,7 @@ namespace System.Web
|
||||
/// they are cleared. The default is false. </param>
|
||||
public void Transfer (string path, bool preserveForm)
|
||||
{
|
||||
HttpValueCollection oldForm = null;
|
||||
if (!preserveForm) {
|
||||
oldForm = _Context.Request.Form as HttpValueCollection;
|
||||
_Context.Request.SetForm (new HttpValueCollection ());
|
||||
}
|
||||
|
||||
Execute (path, null, preserveForm);
|
||||
if (!preserveForm)
|
||||
_Context.Request.SetForm (oldForm);
|
||||
|
||||
_Context.Response.End ();
|
||||
}
|
||||
|
||||
|
||||
@@ -1,3 +1,14 @@
|
||||
2004-10-07 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* DefaultWatcher.cs: if the file is removed between reading the
|
||||
directory and filling the file info, catch the exception and ignore the
|
||||
file. Fixes bug #59482.
|
||||
|
||||
2004-10-07 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* DefaultWatcher.cs: don't use Directory.GetFileSystemEntries when the
|
||||
pattern has no wildcards. Fixes bug #67447.
|
||||
|
||||
2004-09-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* FAMWatcher.cs: s/fam/libfam.so.0/ so that g_module finds it even
|
||||
|
||||
@@ -37,9 +37,10 @@ namespace System.IO {
|
||||
class DefaultWatcherData {
|
||||
public FileSystemWatcher FSW;
|
||||
public string Directory;
|
||||
public string FileMask;
|
||||
public string FileMask; // If NoWildcards, contains the full path to the file.
|
||||
public bool IncludeSubdirs;
|
||||
public bool Enabled;
|
||||
public bool NoWildcards;
|
||||
public DateTime DisabledTime;
|
||||
public Hashtable Files;
|
||||
}
|
||||
@@ -100,7 +101,12 @@ namespace System.IO {
|
||||
|
||||
data.FSW = fsw;
|
||||
data.Directory = fsw.FullPath;
|
||||
data.FileMask = fsw.MangledFilter;
|
||||
data.NoWildcards = !fsw.Pattern.HasWildcard;
|
||||
if (data.NoWildcards)
|
||||
data.FileMask = Path.Combine (data.Directory, fsw.MangledFilter);
|
||||
else
|
||||
data.FileMask = fsw.MangledFilter;
|
||||
|
||||
data.IncludeSubdirs = fsw.IncludeSubdirectories;
|
||||
data.Enabled = true;
|
||||
data.DisabledTime = DateTime.MaxValue;
|
||||
@@ -185,6 +191,7 @@ namespace System.IO {
|
||||
}
|
||||
}
|
||||
|
||||
static string [] NoStringsArray = new string [0];
|
||||
void DoFiles (DefaultWatcherData data, string directory, bool dispatch)
|
||||
{
|
||||
bool direxists = Directory.Exists (directory);
|
||||
@@ -194,10 +201,16 @@ namespace System.IO {
|
||||
}
|
||||
|
||||
string [] files = null;
|
||||
if (direxists) {
|
||||
if (!direxists) {
|
||||
files = NoStringsArray;
|
||||
} else if (!data.NoWildcards) {
|
||||
files = Directory.GetFileSystemEntries (directory, data.FileMask);
|
||||
} else {
|
||||
files = new string [0];
|
||||
// The pattern does not have wildcards
|
||||
if (File.Exists (data.FileMask))
|
||||
files = new string [] { data.FileMask };
|
||||
else
|
||||
files = NoStringsArray;
|
||||
}
|
||||
|
||||
/* Set all as untested */
|
||||
@@ -211,7 +224,14 @@ namespace System.IO {
|
||||
foreach (string filename in files) {
|
||||
FileData fd = (FileData) data.Files [filename];
|
||||
if (fd == null) {
|
||||
data.Files.Add (filename, CreateFileData (directory, filename));
|
||||
try {
|
||||
data.Files.Add (filename, CreateFileData (directory, filename));
|
||||
} catch {
|
||||
// The file might have been removed in the meanwhile
|
||||
data.Files.Remove (filename);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (dispatch)
|
||||
DispatchEvents (data.FSW, FileAction.Added, filename);
|
||||
} else if (fd.Directory == directory) {
|
||||
|
||||
@@ -1,3 +1,29 @@
|
||||
2004-10-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpWebRequest.cs: ProxyQuery returns true when we use a proxy without
|
||||
tunneling a secure connection.
|
||||
|
||||
* ServicePoint.cs: added UseConnect property.
|
||||
|
||||
* ServicePointManager.cs: set the UseConnect property when we use a http
|
||||
proxy for a https connection.
|
||||
|
||||
* WebConnection.cs: setup the tunnled connection when using a proxy and
|
||||
https.
|
||||
|
||||
2004-10-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpWebRequest.cs: ProxyQuery returns true when we use a proxy without
|
||||
tunneling a secure connection.
|
||||
|
||||
* ServicePoint.cs: added UseConnect property.
|
||||
|
||||
* ServicePointManager.cs: set the UseConnect property when we use a http
|
||||
proxy for a https connection.
|
||||
|
||||
* WebConnection.cs: setup the tunnled connection when using a proxy and
|
||||
https.
|
||||
|
||||
2004-09-13 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* HttpWebResponse.cs: remove unused SplitValue method.
|
||||
|
||||
@@ -147,7 +147,7 @@ namespace System.Net
|
||||
get { return webHeaders ["Accept"]; }
|
||||
set {
|
||||
CheckRequestStarted ();
|
||||
webHeaders.SetInternal ("Accept", value);
|
||||
webHeaders.RemoveAndAdd ("Accept", value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -199,7 +199,7 @@ namespace System.Net
|
||||
if (keepAlive && val.IndexOf ("keep-alive") == -1)
|
||||
value = value + ", Keep-Alive";
|
||||
|
||||
webHeaders.SetInternal ("Connection", value);
|
||||
webHeaders.RemoveAndAdd ("Connection", value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -231,7 +231,7 @@ namespace System.Net
|
||||
webHeaders.RemoveInternal ("Content-Type");
|
||||
return;
|
||||
}
|
||||
webHeaders.SetInternal ("Content-Type", value);
|
||||
webHeaders.RemoveAndAdd ("Content-Type", value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -266,7 +266,7 @@ namespace System.Net
|
||||
if (val == "100-continue")
|
||||
throw new ArgumentException ("100-Continue cannot be set with this property.",
|
||||
"value");
|
||||
webHeaders.SetInternal ("Expect", value);
|
||||
webHeaders.RemoveAndAdd ("Expect", value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -452,7 +452,7 @@ namespace System.Net
|
||||
if (!sendChunked)
|
||||
throw new ArgumentException ("SendChunked must be True", "value");
|
||||
|
||||
webHeaders.SetInternal ("Transfer-Encoding", value);
|
||||
webHeaders.RemoveAndAdd ("Transfer-Encoding", value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -484,7 +484,7 @@ namespace System.Net
|
||||
}
|
||||
|
||||
internal bool ProxyQuery {
|
||||
get { return servicePoint.UsesProxy; }
|
||||
get { return servicePoint.UsesProxy && !servicePoint.UseConnect; }
|
||||
}
|
||||
|
||||
// Methods
|
||||
@@ -852,13 +852,13 @@ namespace System.Net
|
||||
webHeaders.RemoveInternal ("Transfer-Encoding");
|
||||
} else if (sendChunked) {
|
||||
continue100 = true;
|
||||
webHeaders.SetInternal ("Transfer-Encoding", "chunked");
|
||||
webHeaders.RemoveAndAdd ("Transfer-Encoding", "chunked");
|
||||
webHeaders.RemoveInternal ("Content-Length");
|
||||
}
|
||||
|
||||
if (actualVersion == HttpVersion.Version11 && continue100 &&
|
||||
servicePoint.SendContinue) { // RFC2616 8.2.3
|
||||
webHeaders.SetInternal ("Expect" , "100-continue");
|
||||
webHeaders.RemoveAndAdd ("Expect" , "100-continue");
|
||||
expectContinue = true;
|
||||
} else {
|
||||
webHeaders.RemoveInternal ("Expect");
|
||||
@@ -871,9 +871,9 @@ namespace System.Net
|
||||
servicePoint.ProtocolVersion == HttpVersion.Version10);
|
||||
|
||||
if (keepAlive && (version == HttpVersion.Version10 || spoint10)) {
|
||||
webHeaders.SetInternal (connectionHeader, "keep-alive");
|
||||
webHeaders.RemoveAndAdd (connectionHeader, "keep-alive");
|
||||
} else if (!keepAlive && version == HttpVersion.Version11) {
|
||||
webHeaders.SetInternal (connectionHeader, "close");
|
||||
webHeaders.RemoveAndAdd (connectionHeader, "close");
|
||||
}
|
||||
|
||||
webHeaders.SetInternal ("Host", actualUri.Authority);
|
||||
@@ -883,9 +883,9 @@ namespace System.Net
|
||||
webHeaders.SetInternal ("Cookie", cookieHeader);
|
||||
}
|
||||
|
||||
if (!usedPreAuth && preAuthenticate) {
|
||||
if (!usedPreAuth && preAuthenticate)
|
||||
DoPreAuthenticate ();
|
||||
}
|
||||
|
||||
return webHeaders.ToString ();
|
||||
}
|
||||
|
||||
|
||||
@@ -52,6 +52,7 @@ namespace System.Net
|
||||
bool usesProxy;
|
||||
Hashtable groups;
|
||||
bool sendContinue = true;
|
||||
bool useConnect;
|
||||
#if NET_1_1
|
||||
bool useNagle;
|
||||
#endif
|
||||
@@ -160,6 +161,11 @@ namespace System.Net
|
||||
set { usesProxy = value; }
|
||||
}
|
||||
|
||||
internal bool UseConnect {
|
||||
get { return useConnect; }
|
||||
set { useConnect = value; }
|
||||
}
|
||||
|
||||
internal bool AvailableForRecycling {
|
||||
get {
|
||||
return CurrentConnections == 0
|
||||
|
||||
@@ -186,11 +186,16 @@ namespace System.Net
|
||||
RecycleServicePoints ();
|
||||
|
||||
bool usesProxy = false;
|
||||
bool useConnect = false;
|
||||
if (proxy != null && !proxy.IsBypassed(address)) {
|
||||
usesProxy = true;
|
||||
bool isSecure = address.Scheme == "https";
|
||||
address = proxy.GetProxy (address);
|
||||
if (address.Scheme != "http" && address.Scheme != "https")
|
||||
if (address.Scheme != "http" && !isSecure)
|
||||
throw new NotSupportedException ("Proxy scheme not supported.");
|
||||
|
||||
if (isSecure && address.Scheme == "http")
|
||||
useConnect = true;
|
||||
}
|
||||
|
||||
address = new Uri (address.Scheme + "://" + address.Authority);
|
||||
@@ -212,6 +217,7 @@ namespace System.Net
|
||||
sp.UseNagleAlgorithm = useNagle;
|
||||
#endif
|
||||
sp.UsesProxy = usesProxy;
|
||||
sp.UseConnect = useConnect;
|
||||
servicePoints.Add (address, sp);
|
||||
}
|
||||
|
||||
|
||||
@@ -148,6 +148,70 @@ namespace System.Net
|
||||
}
|
||||
}
|
||||
|
||||
bool CreateTunnel (HttpWebRequest request, Stream stream, out byte [] buffer)
|
||||
{
|
||||
StringBuilder sb = new StringBuilder ();
|
||||
sb.Append ("CONNECT ");
|
||||
sb.Append (request.Address.Host);
|
||||
sb.Append (':');
|
||||
sb.Append (request.Address.Port);
|
||||
sb.Append (" HTTP/");
|
||||
if (request.ServicePoint.ProtocolVersion == HttpVersion.Version11)
|
||||
sb.Append ("1.1");
|
||||
else
|
||||
sb.Append ("1.0");
|
||||
|
||||
sb.Append ("\r\nHost: ");
|
||||
sb.Append (request.Address.Authority);
|
||||
if (request.Headers ["Proxy-Authorization"] != null) {
|
||||
sb.Append ("\r\nProxy-Authorization: ");
|
||||
sb.Append (request.Headers ["Proxy-Authorization"]);
|
||||
}
|
||||
|
||||
sb.Append ("\r\n\r\n");
|
||||
byte [] connectBytes = Encoding.Default.GetBytes (sb.ToString ());
|
||||
stream.Write (connectBytes, 0, connectBytes.Length);
|
||||
return ReadHeaders (request, stream, out buffer);
|
||||
}
|
||||
|
||||
bool ReadHeaders (HttpWebRequest request, Stream stream, out byte [] retBuffer)
|
||||
{
|
||||
retBuffer = null;
|
||||
|
||||
byte [] buffer = new byte [256];
|
||||
MemoryStream ms = new MemoryStream ();
|
||||
bool gotStatus = false;
|
||||
|
||||
while (true) {
|
||||
int n = stream.Read (buffer, 0, 256);
|
||||
ms.Write (buffer, 0, n);
|
||||
int start = 0;
|
||||
string str = null;
|
||||
while (ReadLine (ms.GetBuffer (), ref start, (int) ms.Length, ref str)) {
|
||||
if (str == null) {
|
||||
if (ms.Length - start > 0) {
|
||||
retBuffer = new byte [ms.Length - start];
|
||||
Buffer.BlockCopy (ms.GetBuffer (), start, retBuffer, 0, retBuffer.Length);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
if (gotStatus)
|
||||
continue;
|
||||
|
||||
int spaceidx = str.IndexOf (' ');
|
||||
if (spaceidx == -1)
|
||||
throw new Exception ();
|
||||
|
||||
int resultCode = Int32.Parse (str.Substring (spaceidx + 1, 3));
|
||||
if (resultCode != 200)
|
||||
throw new Exception ();
|
||||
|
||||
gotStatus = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool CreateStream (HttpWebRequest request)
|
||||
{
|
||||
try {
|
||||
@@ -156,9 +220,16 @@ namespace System.Net
|
||||
ssl = true;
|
||||
EnsureSSLStreamAvailable ();
|
||||
if (!reused || nstream == null || nstream.GetType () != sslStream) {
|
||||
object[] args = new object [3] { serverStream,
|
||||
byte [] buffer = null;
|
||||
if (sPoint.UseConnect) {
|
||||
bool ok = CreateTunnel (request, serverStream, out buffer);
|
||||
if (!ok)
|
||||
return false;
|
||||
}
|
||||
|
||||
object[] args = new object [4] { serverStream,
|
||||
request.ClientCertificates,
|
||||
request };
|
||||
request, buffer};
|
||||
nstream = (Stream) Activator.CreateInstance (sslStream, args);
|
||||
}
|
||||
// we also need to set ServicePoint.Certificate
|
||||
|
||||
@@ -267,7 +267,18 @@ namespace System.Net
|
||||
base.Set (name, value);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
internal void RemoveAndAdd (string name, string value)
|
||||
{
|
||||
if (value == null)
|
||||
value = String.Empty;
|
||||
else
|
||||
value = value.Trim ();
|
||||
|
||||
base.Remove (name);
|
||||
base.Set (name, value);
|
||||
}
|
||||
|
||||
internal void RemoveInternal (string name)
|
||||
{
|
||||
if (name == null)
|
||||
|
||||
@@ -1,3 +1,8 @@
|
||||
2004-10-06 Zoltan Varga <[email protected]>
|
||||
|
||||
* ModuleBuilder.cs (GetTypes): Fix length of returned array. Fixes
|
||||
#65931.
|
||||
|
||||
2004-10-04 Zoltan Varga <[email protected]>
|
||||
|
||||
* ModuleBuilder.cs (DefineType): Check for duplicate type names. Fixes
|
||||
|
||||
@@ -435,7 +435,7 @@ namespace System.Reflection.Emit {
|
||||
if (types == null)
|
||||
return new TypeBuilder [0];
|
||||
|
||||
int n = types.Length;
|
||||
int n = num_types;
|
||||
TypeBuilder [] copy = new TypeBuilder [n];
|
||||
Array.Copy (types, copy, n);
|
||||
|
||||
|
||||
@@ -1,3 +1,9 @@
|
||||
2004-10-05 Sebastien Pouliot <[email protected]>
|
||||
|
||||
* PrincipalPermission.cs: Fixed bug where a change to a permission
|
||||
(e.g. Copy, Union) could affect multiple instances. Fixed FromXml
|
||||
to clear existing entries.
|
||||
|
||||
2004-06-10 Gert Driesen <[email protected]>
|
||||
|
||||
* StrongNameIdentityPermission.cs: removed extra useless finalizer
|
||||
|
||||
@@ -98,7 +98,7 @@ namespace System.Security.Permissions {
|
||||
|
||||
internal PrincipalPermission (ArrayList principals)
|
||||
{
|
||||
this.principals = principals;
|
||||
this.principals = (ArrayList) principals.Clone ();
|
||||
}
|
||||
|
||||
// Properties
|
||||
@@ -147,6 +147,7 @@ namespace System.Security.Permissions {
|
||||
if ((esd.Attributes ["version"] as string) != "1")
|
||||
throw new ArgumentException ("wrong version");
|
||||
|
||||
principals.Clear ();
|
||||
// Children is null, not empty, when no child is present
|
||||
if (esd.Children != null) {
|
||||
foreach (SecurityElement se in esd.Children) {
|
||||
@@ -273,7 +274,7 @@ namespace System.Security.Permissions {
|
||||
|
||||
PrincipalPermission union = new PrincipalPermission (principals);
|
||||
foreach (PrincipalInfo pi in o.principals)
|
||||
principals.Add (pi);
|
||||
union.principals.Add (pi);
|
||||
|
||||
return union;
|
||||
}
|
||||
@@ -284,4 +285,4 @@ namespace System.Security.Permissions {
|
||||
return 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,17 @@
|
||||
2004-10-08 Zoltan Varga <[email protected]>
|
||||
|
||||
* Convert.cs (ToType): Throw an exception when converting null to a
|
||||
valuetype. Fixes #67780.
|
||||
|
||||
2004-10-08 Atsushi Enomoto <[email protected]>
|
||||
|
||||
* DateTime.cs : Removed incorrectly injected HEAD fix.
|
||||
|
||||
2004-10-08 Atsushi Enomoto <[email protected]>
|
||||
|
||||
* DateTime.cs : When it it not exact parse, 'Z' is allowed as a suffix
|
||||
of m/s/t/z. This fixes bug 66723.
|
||||
|
||||
2004-10-04 Zoltan Varga <[email protected]>
|
||||
|
||||
* AppDomain.cs: Make ThreadStatic variables static. Fixes #56614.
|
||||
|
||||
@@ -2686,8 +2686,12 @@ namespace System {
|
||||
internal static object ToType (object value, Type conversionType,
|
||||
IFormatProvider provider)
|
||||
{
|
||||
if (value == null)
|
||||
return null;
|
||||
if (value == null) {
|
||||
if ((conversionType != null) && conversionType.IsValueType)
|
||||
throw new InvalidCastException ("Null object can not be converted to a value type.");
|
||||
else
|
||||
return null;
|
||||
}
|
||||
|
||||
if (conversionType == null)
|
||||
throw new InvalidCastException ("Cannot cast to destination type.");
|
||||
|
||||
@@ -1190,6 +1190,22 @@ namespace System
|
||||
|
||||
s = s.Substring (num_parsed);
|
||||
|
||||
if (!exact) {
|
||||
switch (chars [pos]) {
|
||||
case 'm':
|
||||
case 's':
|
||||
case 'f':
|
||||
case 'z':
|
||||
if (s.Length > 0 && s [0] == 'Z'
|
||||
&& (pos + 1 == chars.Length
|
||||
|| chars [pos + 1] != 'Z')) {
|
||||
useutc = true;
|
||||
s = s.Substring (1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
pos = pos + num + 1;
|
||||
num = 0;
|
||||
}
|
||||
|
||||
@@ -197,7 +197,6 @@ get_typespec (MonoImage *m, guint32 idx)
|
||||
if (s)
|
||||
g_string_append (res, s);
|
||||
}
|
||||
g_string_append (res, "*");
|
||||
break;
|
||||
|
||||
case MONO_TYPE_FNPTR:
|
||||
|
||||
@@ -1,9 +1,3 @@
|
||||
2004-07-05 Zoltan Varga <[email protected]>
|
||||
|
||||
* mintops.h: Applied patch from Marcin Krzyzanowski ([email protected]). Add support for unaligned access on little endian machines.
|
||||
|
||||
* interp.c:Applied patch from Marcin Krzyzanowski ([email protected]). Fix crash seen on amd64.
|
||||
|
||||
2004-06-24 David Waite <[email protected]>
|
||||
|
||||
* interp.c: change to C90-style comments from C99/C++-style
|
||||
|
||||
@@ -1164,7 +1164,7 @@ handle_enum:
|
||||
}
|
||||
}
|
||||
|
||||
if (method->klass->valuetype && obj)
|
||||
if (method->klass->valuetype)
|
||||
/* Unbox the instance, since valuetype methods expect an interior pointer. */
|
||||
obj = mono_object_unbox (obj);
|
||||
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
#ifndef __INTERPRETER_MINTOPS_H
|
||||
#define __INTERPRETER_MINTOPS_H
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
typedef enum
|
||||
{
|
||||
MintOpNoArgs,
|
||||
@@ -31,19 +29,11 @@ enum {
|
||||
#undef OPDEF
|
||||
|
||||
#if NO_UNALIGNED_ACCESS
|
||||
# if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
||||
#define READ32(x) (((guint16 *)(x)) [0] | ((guint16 *)(x)) [1] << 16)
|
||||
#define READ64(x) ((guint64)((guint16 *)(x)) [0] | \
|
||||
(guint64)((guint16 *)(x)) [1] << 16 | \
|
||||
(guint64)((guint16 *)(x)) [2] << 32 | \
|
||||
(guint64)((guint16 *)(x)) [3] << 48)
|
||||
# else
|
||||
#define READ32(x) (((guint16 *)(x)) [0] << 16 | ((guint16 *)(x)) [1])
|
||||
#define READ64(x) ((guint64)((guint16 *)(x)) [0] << 48 | \
|
||||
(guint64)((guint16 *)(x)) [1] << 32 | \
|
||||
(guint64)((guint16 *)(x)) [2] << 16 | \
|
||||
(guint64)((guint16 *)(x)) [3])
|
||||
# endif
|
||||
#else /* unaligned access OK */
|
||||
#define READ32(x) (*(guint32 *)(x))
|
||||
#define READ64(x) (*(guint64 *)(x))
|
||||
|
||||
@@ -1,116 +1,3 @@
|
||||
2004-09-28 Dick Porter <[email protected]>
|
||||
|
||||
* io.c (pipe_close_private): Fix one small typo in the last change
|
||||
that totally hosed process creation with redirected pipes.
|
||||
|
||||
2004-09-24 Dick Porter <[email protected]>
|
||||
|
||||
* wapi-private.h:
|
||||
* sockets.c:
|
||||
* socket-private.h:
|
||||
* io.c:
|
||||
* io-private.h:
|
||||
* handles-private.h: Cope when a file descriptor is reused while
|
||||
the handle that thought it owned it is still referenced, instead
|
||||
of asserting. Probably fixes bug 66479, though we've been unable
|
||||
to reproduce it.
|
||||
|
||||
2004-09-09 Dick Porter <[email protected]>
|
||||
|
||||
* error.c:
|
||||
* io.c: Set error codes everywhere.
|
||||
|
||||
2004-09-06 Dick Porter <[email protected]>
|
||||
|
||||
* handles.c (_wapi_handle_unref): Reset the private record's type
|
||||
(_wapi_handle_process_fork): Fix long-standing bug in checking
|
||||
handle return values. Also do the required bookkeeping with the
|
||||
new process's handles.
|
||||
|
||||
* daemon.c: When creating a new process's handles, check whether
|
||||
the shared space needs to be increased
|
||||
|
||||
2004-08-19 Dick Porter <[email protected]>
|
||||
|
||||
* handles.c (_wapi_handle_count_signalled_handles): Fix thinko
|
||||
introduced with the fd offset stuff: unlock handles properly when
|
||||
backing off. Fixes the monologue hang at exit.
|
||||
|
||||
2004-08-18 Dick Porter <[email protected]>
|
||||
|
||||
* sockets.c:
|
||||
* io.c: Check that new fds fit in the table, return error if not
|
||||
|
||||
* daemon.c (_wapi_daemon_main):
|
||||
* handles.c (shared_init): Have all processes agree on a size for
|
||||
the fd table.
|
||||
|
||||
2004-08-17 Dick Porter <[email protected]>
|
||||
|
||||
* daemon.c (process_new):
|
||||
* handles.c (_wapi_handle_new_internal): Cope when the space
|
||||
reserved for file descriptors is larger than the shared segment
|
||||
size. Fixes the crash reported when running mono under gdb on
|
||||
macosx.
|
||||
|
||||
2004-08-16 Dick Porter <[email protected]>
|
||||
|
||||
* sockets.c:
|
||||
* io.c:
|
||||
* handles-private.h (_wapi_handle_fd_offset_to_handle): Improve
|
||||
error checking with passed-in file descriptors.
|
||||
|
||||
2004-08-11 Dick Porter <[email protected]>
|
||||
|
||||
* sockets.c:
|
||||
* io.c: Returned handle values are the file descriptor the handle
|
||||
encapsulates
|
||||
|
||||
* handles.c:
|
||||
* handles-private.h:
|
||||
* daemon.c: Reserve the range of handles that can have the same
|
||||
values as file descriptors. These won't be used, but the values
|
||||
will be used as file, console, pipe or socket handles. The fd to
|
||||
handle mapping is done internally and is invisible to users.
|
||||
Fixes bug 61828.
|
||||
|
||||
* wapi-private.h (_WAPI_HANDLE_VERSION): Increment, because we now
|
||||
reserve a chunk of handle space.
|
||||
|
||||
2004-07-22 Dick Porter <[email protected]>
|
||||
|
||||
* timed-thread.c:
|
||||
* threads.c: Move the destruction of the internal thread data to
|
||||
after the thread has been joined. Fixes bug 61418.
|
||||
|
||||
2004-07-14 Dick Porter <[email protected]>
|
||||
|
||||
* wait.c (test_and_own): When not waiting for all handles to
|
||||
become signalled, only own and return the lowest. All the
|
||||
documentation suggests that the old way was correct, but
|
||||
experimentation shows it actually works like this. Patch by
|
||||
Sébastien Robitaille
|
||||
([email protected]), fixes bug 61511.
|
||||
|
||||
2004-07-08 Dick Porter <[email protected]>
|
||||
|
||||
* io.c (file_seek): If there is a high 32bit offset part, make
|
||||
sure the low part isn't sign-extended. Set error codes when
|
||||
returning failure. Fixes bug 61131.
|
||||
|
||||
2004-07-06 Dick Porter <[email protected]>
|
||||
|
||||
* io.c (file_setfiletime): Check for underflow when converting to
|
||||
time_t values. Set error codes when returning failure. Fixes bug
|
||||
60970.
|
||||
|
||||
2004-07-05 Dick Porter <[email protected]>
|
||||
|
||||
* mutexes.c (mutex_ops_init): Make the named mutex mutex sharable.
|
||||
|
||||
* daemon.c (unref_handle): Only destroy a handle if all processes
|
||||
have released it, not just the current one. Fixes bug 60887.
|
||||
|
||||
2004-06-24 Dick Porter <[email protected]>
|
||||
|
||||
* mutexes.c: Indicate when a named mutex was reused
|
||||
|
||||
+27
-35
@@ -340,14 +340,16 @@ static gboolean unref_handle (ChannelData *channel_data, guint32 handle)
|
||||
channel_data->open_handles[handle]);
|
||||
#endif
|
||||
|
||||
if (_wapi_shared_data[segment]->handles[idx].ref == 0) {
|
||||
if(channel_data->open_handles[handle]==0) {
|
||||
/* This client has released the handle */
|
||||
destroy=TRUE;
|
||||
}
|
||||
|
||||
if(_wapi_shared_data[segment]->handles[idx].ref==0) {
|
||||
gboolean was_file;
|
||||
dev_t device = 0;
|
||||
ino_t inode = 0;
|
||||
|
||||
/* This client has released the handle */
|
||||
destroy=TRUE;
|
||||
|
||||
if (channel_data->open_handles[handle]!=0) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION ": per-process open_handles mismatch, set to %d, should be 0",
|
||||
channel_data->open_handles[handle]);
|
||||
@@ -830,11 +832,23 @@ static void send_reply (GIOChannel *channel, WapiHandleResponse *resp)
|
||||
_wapi_daemon_response (g_io_channel_unix_get_fd (channel), resp);
|
||||
}
|
||||
|
||||
static guint32 new_handle_with_shared_check (WapiHandleType type)
|
||||
/*
|
||||
* process_new:
|
||||
* @channel: The client making the request
|
||||
* @channel_data: Our data for this channel
|
||||
* @type: type to init handle to
|
||||
*
|
||||
* Find a free handle and initialize it to 'type', increase refcnt and
|
||||
* send back a reply to the client.
|
||||
*/
|
||||
static void process_new (GIOChannel *channel, ChannelData *channel_data,
|
||||
WapiHandleType type)
|
||||
{
|
||||
guint32 handle = 0;
|
||||
|
||||
while ((handle = _wapi_handle_new_internal (type)) == 0) {
|
||||
guint32 handle;
|
||||
WapiHandleResponse resp={0};
|
||||
|
||||
handle=_wapi_handle_new_internal (type);
|
||||
if(handle==0) {
|
||||
/* Try and allocate a new shared segment, and have
|
||||
* another go
|
||||
*/
|
||||
@@ -859,34 +873,15 @@ static guint32 new_handle_with_shared_check (WapiHandleType type)
|
||||
channels[i].open_handles=_wapi_g_renew0 (channels[i].open_handles, old_len, new_len);
|
||||
}
|
||||
}
|
||||
|
||||
handle=_wapi_handle_new_internal (type);
|
||||
} else {
|
||||
/* Map failed. Just return 0 meaning "out of
|
||||
* handles"
|
||||
*/
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return(handle);
|
||||
}
|
||||
|
||||
/*
|
||||
* process_new:
|
||||
* @channel: The client making the request
|
||||
* @channel_data: Our data for this channel
|
||||
* @type: type to init handle to
|
||||
*
|
||||
* Find a free handle and initialize it to 'type', increase refcnt and
|
||||
* send back a reply to the client.
|
||||
*/
|
||||
static void process_new (GIOChannel *channel, ChannelData *channel_data,
|
||||
WapiHandleType type)
|
||||
{
|
||||
guint32 handle;
|
||||
WapiHandleResponse resp={0};
|
||||
|
||||
handle = new_handle_with_shared_check (type);
|
||||
|
||||
/* handle might still be set to 0. This is handled at the
|
||||
* client end
|
||||
*/
|
||||
@@ -1071,11 +1066,11 @@ static void process_process_fork (GIOChannel *channel, ChannelData *channel_data
|
||||
* client must check if either handle is 0 and take
|
||||
* appropriate error handling action.
|
||||
*/
|
||||
process_handle = new_handle_with_shared_check (WAPI_HANDLE_PROCESS);
|
||||
process_handle=_wapi_handle_new_internal (WAPI_HANDLE_PROCESS);
|
||||
ref_handle (daemon_channel_data, process_handle);
|
||||
ref_handle (channel_data, process_handle);
|
||||
|
||||
thread_handle = new_handle_with_shared_check (WAPI_HANDLE_THREAD);
|
||||
thread_handle=_wapi_handle_new_internal (WAPI_HANDLE_THREAD);
|
||||
ref_handle (daemon_channel_data, thread_handle);
|
||||
ref_handle (channel_data, thread_handle);
|
||||
|
||||
@@ -1253,7 +1248,7 @@ static void process_process_fork (GIOChannel *channel, ChannelData *channel_data
|
||||
|
||||
resp.u.process_fork.pid=pid;
|
||||
}
|
||||
|
||||
|
||||
resp.u.process_fork.process_handle=process_handle;
|
||||
resp.u.process_fork.thread_handle=thread_handle;
|
||||
|
||||
@@ -1498,9 +1493,6 @@ void _wapi_daemon_main(gpointer data, gpointer scratch)
|
||||
/* Note that we've got the starting segment already */
|
||||
_wapi_shared_data[0]->num_segments=1;
|
||||
_wapi_shm_mapped_segments=1;
|
||||
|
||||
_wapi_fd_offset_table_size=getdtablesize ();
|
||||
_wapi_shared_data[0]->fd_offset_table_size = _wapi_fd_offset_table_size;
|
||||
|
||||
startup ();
|
||||
|
||||
|
||||
@@ -194,14 +194,6 @@ _wapi_get_win32_file_error (gint err)
|
||||
ret = ERROR_NOT_SUPPORTED;
|
||||
break;
|
||||
|
||||
case EBADF:
|
||||
ret = ERROR_INVALID_HANDLE;
|
||||
break;
|
||||
|
||||
case EIO:
|
||||
ret = ERROR_INVALID_HANDLE;
|
||||
break;
|
||||
|
||||
default:
|
||||
g_message ("Unknown errno: %s\n", strerror (err));
|
||||
ret = ERROR_GEN_FAILURE;
|
||||
|
||||
@@ -28,9 +28,6 @@ extern struct _WapiHandlePrivate_list **_wapi_private_data;
|
||||
extern pthread_mutex_t _wapi_shared_mutex;
|
||||
extern guint32 _wapi_shm_mapped_segments;
|
||||
|
||||
extern guint32 _wapi_fd_offset_table_size;
|
||||
extern gpointer *_wapi_fd_offset_table;
|
||||
|
||||
extern guint32 _wapi_handle_new_internal (WapiHandleType type);
|
||||
extern gpointer _wapi_handle_new (WapiHandleType type);
|
||||
extern gboolean _wapi_lookup_handle (gpointer handle, WapiHandleType type,
|
||||
@@ -223,38 +220,11 @@ static inline guint32 _wapi_handle_index (guint32 segment, guint32 idx)
|
||||
return((segment*_WAPI_HANDLES_PER_SEGMENT)+idx);
|
||||
}
|
||||
|
||||
static inline gpointer _wapi_handle_fd_offset_to_handle (gpointer fd_handle)
|
||||
{
|
||||
int fd = GPOINTER_TO_INT (fd_handle);
|
||||
gpointer handle;
|
||||
|
||||
if (fd >= _wapi_fd_offset_table_size) {
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
handle = _wapi_fd_offset_table[fd];
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": Returning fd offset %d of %p", fd,
|
||||
handle);
|
||||
#endif
|
||||
|
||||
return(handle);
|
||||
}
|
||||
|
||||
static inline WapiHandleType _wapi_handle_type (gpointer handle)
|
||||
{
|
||||
guint32 idx;
|
||||
guint32 segment;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
if(segment>=_wapi_shm_mapped_segments)
|
||||
@@ -263,48 +233,6 @@ static inline WapiHandleType _wapi_handle_type (gpointer handle)
|
||||
return(_wapi_handle_get_shared_segment (segment)->handles[idx].type);
|
||||
}
|
||||
|
||||
static inline void _wapi_handle_fd_offset_store (int fd, gpointer handle)
|
||||
{
|
||||
g_assert (fd < _wapi_fd_offset_table_size);
|
||||
|
||||
if (_wapi_fd_offset_table[fd] != NULL && handle != NULL) {
|
||||
gpointer oldhandle = _wapi_fd_offset_table[fd];
|
||||
struct _WapiHandlePrivate *private_handle;
|
||||
guint32 idx;
|
||||
guint32 segment;
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION
|
||||
": Reassigning fd offset %d from %p", fd,
|
||||
oldhandle);
|
||||
#endif
|
||||
|
||||
/* The WapiFDMapped struct at the head of the private
|
||||
* handle data means we don't need to do a full
|
||||
* lookup, and we don't need to know the handle type.
|
||||
*/
|
||||
g_assert (_wapi_handle_type (oldhandle) == WAPI_HANDLE_FILE ||
|
||||
_wapi_handle_type (oldhandle) == WAPI_HANDLE_CONSOLE ||
|
||||
_wapi_handle_type (oldhandle) == WAPI_HANDLE_PIPE ||
|
||||
_wapi_handle_type (oldhandle) == WAPI_HANDLE_SOCKET);
|
||||
|
||||
_wapi_handle_segment (oldhandle, &segment, &idx);
|
||||
_wapi_handle_ensure_mapped (segment);
|
||||
|
||||
private_handle=&_wapi_handle_get_private_segment(segment)->handles[idx];
|
||||
((WapiFDMapped *)(&private_handle->u))->assigned = FALSE;
|
||||
}
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size || handle==NULL);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": Assigning fd offset %d to %p", fd,
|
||||
handle);
|
||||
#endif
|
||||
|
||||
_wapi_fd_offset_table[fd]=handle;
|
||||
}
|
||||
|
||||
static inline void _wapi_handle_set_signal_state (gpointer handle,
|
||||
gboolean state,
|
||||
gboolean broadcast)
|
||||
@@ -314,8 +242,6 @@ static inline void _wapi_handle_set_signal_state (gpointer handle,
|
||||
struct _WapiHandleShared *shared_handle;
|
||||
int thr_ret;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
shared_handle=&_wapi_handle_get_shared_segment (segment)->handles[idx];
|
||||
|
||||
@@ -391,8 +317,6 @@ static inline gboolean _wapi_handle_issignalled (gpointer handle)
|
||||
guint32 idx;
|
||||
guint32 segment;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
return(_wapi_handle_get_shared_segment (segment)->handles[idx].signalled);
|
||||
@@ -428,8 +352,6 @@ static inline int _wapi_handle_lock_handle (gpointer handle)
|
||||
guint32 idx;
|
||||
guint32 segment;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": locking handle %p", handle);
|
||||
#endif
|
||||
@@ -447,8 +369,6 @@ static inline int _wapi_handle_unlock_handle (gpointer handle)
|
||||
guint32 segment;
|
||||
int ret;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": unlocking handle %p", handle);
|
||||
#endif
|
||||
|
||||
+25
-141
@@ -77,9 +77,6 @@ pthread_mutex_t _wapi_shared_mutex=PTHREAD_MUTEX_INITIALIZER;
|
||||
*/
|
||||
guint32 _wapi_shm_mapped_segments;
|
||||
|
||||
guint32 _wapi_fd_offset_table_size;
|
||||
gpointer *_wapi_fd_offset_table=NULL;
|
||||
|
||||
static void shared_init (void)
|
||||
{
|
||||
struct sockaddr_un shared_socket_address;
|
||||
@@ -89,7 +86,7 @@ static void shared_init (void)
|
||||
|
||||
_wapi_shared_data=g_new0 (struct _WapiHandleShared_list *, 1);
|
||||
_wapi_private_data=g_new0 (struct _WapiHandlePrivate_list *, 1);
|
||||
|
||||
|
||||
attach_again:
|
||||
|
||||
#ifndef DISABLE_SHARED_HANDLES
|
||||
@@ -149,9 +146,6 @@ attach_again:
|
||||
|
||||
goto attach_again;
|
||||
}
|
||||
} else {
|
||||
_wapi_fd_offset_table_size = _wapi_shared_data[0]->fd_offset_table_size;
|
||||
_wapi_fd_offset_table=g_new0 (gpointer, _wapi_fd_offset_table_size);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -164,10 +158,6 @@ attach_again:
|
||||
_wapi_shared_data[0]->num_segments=1;
|
||||
|
||||
_wapi_shared_scratch=g_new0 (struct _WapiHandleScratch, 1);
|
||||
|
||||
_wapi_fd_offset_table_size=getdtablesize ();
|
||||
_wapi_fd_offset_table=g_new0 (gpointer,
|
||||
_wapi_fd_offset_table_size);
|
||||
}
|
||||
_wapi_private_data[0]=g_new0 (struct _WapiHandlePrivate_list, 1);
|
||||
_wapi_shm_mapped_segments=1;
|
||||
@@ -250,7 +240,6 @@ guint32 _wapi_handle_new_internal (WapiHandleType type)
|
||||
guint32 i, j;
|
||||
static guint32 last=1;
|
||||
int thr_ret;
|
||||
guint32 num_segments = _wapi_handle_get_shared_segment (0)->num_segments;
|
||||
|
||||
/* A linear scan should be fast enough. Start from the last
|
||||
* allocation, assuming that handles are allocated more often
|
||||
@@ -261,7 +250,8 @@ guint32 _wapi_handle_new_internal (WapiHandleType type)
|
||||
#endif
|
||||
again:
|
||||
_wapi_handle_segment (GUINT_TO_POINTER (last), &segment, &idx);
|
||||
for(i=segment; i < num_segments; i++) {
|
||||
for(i=segment; i<_wapi_handle_get_shared_segment (0)->num_segments;
|
||||
i++) {
|
||||
if(i!=segment) {
|
||||
idx=0;
|
||||
}
|
||||
@@ -269,20 +259,8 @@ again:
|
||||
for(j=idx; j<_WAPI_HANDLES_PER_SEGMENT; j++) {
|
||||
struct _WapiHandleShared *shared;
|
||||
|
||||
/* Make sure we dont try and assign the
|
||||
* handles that would clash with fds
|
||||
*/
|
||||
if ((i * _WAPI_HANDLES_PER_SEGMENT + j) < _wapi_fd_offset_table_size) {
|
||||
i = _wapi_fd_offset_table_size / _WAPI_HANDLES_PER_SEGMENT;
|
||||
j = _wapi_fd_offset_table_size - (i * _WAPI_HANDLES_PER_SEGMENT);
|
||||
|
||||
if (i >= num_segments) {
|
||||
/* Need to get the caller to
|
||||
* add more shared segments
|
||||
*/
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Make sure we dont try and assign handle 0 */
|
||||
if (i==0 && j==0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -336,7 +314,7 @@ gpointer _wapi_handle_new (WapiHandleType type)
|
||||
int thr_ret;
|
||||
|
||||
mono_once (&shared_init_once, shared_init);
|
||||
|
||||
|
||||
again:
|
||||
if(shared==TRUE) {
|
||||
new.type=WapiHandleRequestType_New;
|
||||
@@ -358,7 +336,8 @@ again:
|
||||
thr_ret = pthread_mutex_lock (&scan_mutex);
|
||||
g_assert (thr_ret == 0);
|
||||
|
||||
while ((handle_idx = _wapi_handle_new_internal (type)) == 0) {
|
||||
handle_idx=_wapi_handle_new_internal (type);
|
||||
if(handle_idx==0) {
|
||||
/* Try and get a new segment, and have another go */
|
||||
segment=_wapi_handle_get_shared_segment (0)->num_segments;
|
||||
_wapi_handle_ensure_mapped (segment);
|
||||
@@ -366,6 +345,7 @@ again:
|
||||
if(_wapi_handle_get_shared_segment (segment)!=NULL) {
|
||||
/* Got a new segment */
|
||||
_wapi_handle_get_shared_segment (0)->num_segments++;
|
||||
handle_idx=_wapi_handle_new_internal (type);
|
||||
} else {
|
||||
/* Map failed. Just return 0 meaning
|
||||
* "out of handles"
|
||||
@@ -381,9 +361,6 @@ again:
|
||||
pthread_cleanup_pop (0);
|
||||
}
|
||||
|
||||
/* Make sure we left the space for fd mappings */
|
||||
g_assert (handle_idx >= _wapi_fd_offset_table_size);
|
||||
|
||||
if(handle_idx==0) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION ": Ran out of handles!");
|
||||
|
||||
@@ -437,8 +414,6 @@ gboolean _wapi_lookup_handle (gpointer handle, WapiHandleType type,
|
||||
guint32 idx;
|
||||
guint32 segment;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_handle_ensure_mapped (segment);
|
||||
|
||||
@@ -617,8 +592,6 @@ gpointer _wapi_search_handle_namespace (WapiHandleType type,
|
||||
|
||||
void _wapi_handle_ref (gpointer handle)
|
||||
{
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
if(shared==TRUE) {
|
||||
WapiHandleRequest req={0};
|
||||
WapiHandleResponse resp={0};
|
||||
@@ -655,8 +628,6 @@ void _wapi_handle_unref (gpointer handle)
|
||||
gboolean destroy = FALSE;
|
||||
int thr_ret;
|
||||
|
||||
g_assert (GPOINTER_TO_UINT (handle) >= _wapi_fd_offset_table_size);
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
if(shared==TRUE) {
|
||||
@@ -705,7 +676,6 @@ void _wapi_handle_unref (gpointer handle)
|
||||
|
||||
_wapi_handle_ops_close_private (handle);
|
||||
_wapi_handle_get_shared_segment (segment)->handles[idx].type=WAPI_HANDLE_UNUSED;
|
||||
_wapi_handle_get_private_segment (segment)->handles[idx].type=WAPI_HANDLE_UNUSED;
|
||||
|
||||
/* Destroy the mutex and cond var. We hope nobody
|
||||
* tried to grab them between the handle unlock and
|
||||
@@ -1210,10 +1180,6 @@ gboolean _wapi_handle_test_capabilities (gpointer handle,
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1231,10 +1197,6 @@ void _wapi_handle_ops_close_shared (gpointer handle)
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1249,10 +1211,6 @@ void _wapi_handle_ops_close_private (gpointer handle)
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1274,10 +1232,6 @@ void _wapi_handle_ops_signal (gpointer handle)
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1292,10 +1246,6 @@ void _wapi_handle_ops_own (gpointer handle)
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1310,10 +1260,6 @@ gboolean _wapi_handle_ops_isowned (gpointer handle)
|
||||
guint32 idx, segment;
|
||||
WapiHandleType type;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
type=_wapi_handle_get_shared_segment (segment)->handles[idx].type;
|
||||
@@ -1338,14 +1284,6 @@ gboolean _wapi_handle_ops_isowned (gpointer handle)
|
||||
*/
|
||||
gboolean CloseHandle(gpointer handle)
|
||||
{
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
if (handle == NULL) {
|
||||
return(FALSE);
|
||||
}
|
||||
|
||||
_wapi_handle_unref (handle);
|
||||
|
||||
return(TRUE);
|
||||
@@ -1365,17 +1303,12 @@ gboolean _wapi_handle_count_signalled_handles (guint32 numhandles,
|
||||
again:
|
||||
for(i=0; i<numhandles; i++) {
|
||||
guint32 idx, segment;
|
||||
gpointer handle = handles[i];
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_handle_segment (handles[i], &segment, &idx);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": attempting to lock %p",
|
||||
handle);
|
||||
handles[i]);
|
||||
#endif
|
||||
|
||||
ret=mono_mutex_trylock (&_wapi_handle_get_shared_segment (segment)->handles[idx].signal_mutex);
|
||||
@@ -1384,17 +1317,11 @@ again:
|
||||
struct timespec sleepytime;
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": attempt failed for %p: %s", handle, strerror (ret));
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": attempt failed for %p", handles[i]);
|
||||
#endif
|
||||
|
||||
while(i--) {
|
||||
handle = handles[i];
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_handle_segment (handles[i], &segment, &idx);
|
||||
thr_ret = mono_mutex_unlock (&_wapi_handle_get_shared_segment (segment)->handles[idx].signal_mutex);
|
||||
g_assert (thr_ret == 0);
|
||||
}
|
||||
@@ -1432,29 +1359,24 @@ again:
|
||||
|
||||
for(i=0; i<numhandles; i++) {
|
||||
guint32 idx, segment;
|
||||
gpointer handle = handles[i];
|
||||
|
||||
_wapi_handle_ref (handles[i]);
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_ref (handle);
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_handle_segment (handles[i], &segment, &idx);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": Checking handle %p",
|
||||
handle);
|
||||
handles[i]);
|
||||
#endif
|
||||
|
||||
if(((_wapi_handle_test_capabilities (handle, WAPI_HANDLE_CAP_OWN)==TRUE) &&
|
||||
(_wapi_handle_ops_isowned (handle)==TRUE)) ||
|
||||
if(((_wapi_handle_test_capabilities (handles[i], WAPI_HANDLE_CAP_OWN)==TRUE) &&
|
||||
(_wapi_handle_ops_isowned (handles[i])==TRUE)) ||
|
||||
(_wapi_handle_get_shared_segment (segment)->handles[idx].signalled==TRUE)) {
|
||||
count++;
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION
|
||||
": Handle %p signalled", handle);
|
||||
": Handle %p signalled", handles[i]);
|
||||
#endif
|
||||
if(*lowest>i) {
|
||||
*lowest=i;
|
||||
@@ -1490,23 +1412,18 @@ void _wapi_handle_unlock_handles (guint32 numhandles, gpointer *handles)
|
||||
|
||||
for(i=0; i<numhandles; i++) {
|
||||
guint32 idx, segment;
|
||||
gpointer handle = handles[i];
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
_wapi_handle_segment (handles[i], &segment, &idx);
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": unlocking handle %p",
|
||||
handle);
|
||||
handles[i]);
|
||||
#endif
|
||||
|
||||
thr_ret = mono_mutex_unlock (&_wapi_handle_get_shared_segment (segment)->handles[idx].signal_mutex);
|
||||
g_assert (thr_ret == 0);
|
||||
|
||||
_wapi_handle_unref (handle);
|
||||
_wapi_handle_unref (handles[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1578,10 +1495,6 @@ int _wapi_handle_wait_signal_handle (gpointer handle)
|
||||
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
|
||||
guint32 idx, segment;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
return(mono_cond_wait (&_wapi_handle_get_shared_segment (segment)->handles[idx].signal_cond,
|
||||
@@ -1591,10 +1504,6 @@ int _wapi_handle_wait_signal_handle (gpointer handle)
|
||||
struct timespec fake_timeout;
|
||||
int ret;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_calc_timeout (&fake_timeout, 100);
|
||||
|
||||
@@ -1615,10 +1524,6 @@ int _wapi_handle_timedwait_signal_handle (gpointer handle,
|
||||
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
|
||||
guint32 idx, segment;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
|
||||
return(mono_cond_timedwait (&_wapi_handle_get_shared_segment (segment)->handles[idx].signal_cond,
|
||||
@@ -1629,10 +1534,6 @@ int _wapi_handle_timedwait_signal_handle (gpointer handle,
|
||||
struct timespec fake_timeout;
|
||||
int ret;
|
||||
|
||||
if (GPOINTER_TO_UINT (handle) < _wapi_fd_offset_table_size) {
|
||||
handle = _wapi_handle_fd_offset_to_handle (handle);
|
||||
}
|
||||
|
||||
_wapi_handle_segment (handle, &segment, &idx);
|
||||
_wapi_calc_timeout (&fake_timeout, 100);
|
||||
|
||||
@@ -1708,26 +1609,9 @@ gboolean _wapi_handle_process_fork (guint32 cmd, guint32 env, guint32 dir,
|
||||
* exec_errno will be set, and the handle will be
|
||||
* signalled immediately.
|
||||
*/
|
||||
if(*process_handle==0 || *thread_handle==0) {
|
||||
if(process_handle==0 || thread_handle==0) {
|
||||
return(FALSE);
|
||||
} else {
|
||||
/* This call returns new handles, so we need to do
|
||||
* a little bookkeeping
|
||||
*/
|
||||
if (_wapi_private_data != NULL) {
|
||||
guint32 segment, idx;
|
||||
|
||||
_wapi_handle_segment (*process_handle,
|
||||
&segment, &idx);
|
||||
_wapi_handle_ensure_mapped (segment);
|
||||
_wapi_handle_get_private_segment (segment)->handles[idx].type = WAPI_HANDLE_PROCESS;
|
||||
|
||||
_wapi_handle_segment (*thread_handle,
|
||||
&segment, &idx);
|
||||
_wapi_handle_ensure_mapped (segment);
|
||||
_wapi_handle_get_private_segment (segment)->handles[idx].type = WAPI_HANDLE_THREAD;
|
||||
}
|
||||
|
||||
return(TRUE);
|
||||
}
|
||||
} else {
|
||||
|
||||
@@ -34,9 +34,13 @@ struct _WapiHandle_file
|
||||
ino_t inode;
|
||||
};
|
||||
|
||||
/* The boolean is for distinguishing between a zeroed struct being not
|
||||
* as yet assigned, and one containing a valid fd 0
|
||||
*/
|
||||
struct _WapiHandlePrivate_file
|
||||
{
|
||||
WapiFDMapped fd_mapped;
|
||||
int fd;
|
||||
gboolean assigned;
|
||||
gboolean async;
|
||||
WapiOverlappedCB callback;
|
||||
};
|
||||
|
||||
+131
-564
File diff suppressed because it is too large.
Load diff
+2
-18
@@ -23,8 +23,9 @@
|
||||
#undef DEBUG
|
||||
|
||||
/* This is used to serialise mutex creation when names are given
|
||||
* (FIXME: make it process-shared)
|
||||
*/
|
||||
static mono_mutex_t named_mutex_mutex;
|
||||
static mono_mutex_t named_mutex_mutex = MONO_MUTEX_INITIALIZER;
|
||||
|
||||
static void mutex_close_shared (gpointer handle);
|
||||
static void mutex_signal(gpointer handle);
|
||||
@@ -43,23 +44,6 @@ static mono_once_t mutex_ops_once=MONO_ONCE_INIT;
|
||||
|
||||
static void mutex_ops_init (void)
|
||||
{
|
||||
int thr_ret;
|
||||
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
|
||||
pthread_mutexattr_t mutex_shared_attr;
|
||||
|
||||
thr_ret = mono_mutexattr_init (&mutex_shared_attr);
|
||||
g_assert (thr_ret == 0);
|
||||
|
||||
thr_ret = mono_mutexattr_setpshared (&mutex_shared_attr,
|
||||
PTHREAD_PROCESS_SHARED);
|
||||
g_assert (thr_ret == 0);
|
||||
|
||||
thr_ret = mono_mutex_init (&named_mutex_mutex, &mutex_shared_attr);
|
||||
g_assert (thr_ret == 0);
|
||||
#else
|
||||
thr_ret = mono_mutex_init (&named_mutex_mutex, NULL);
|
||||
#endif
|
||||
|
||||
_wapi_handle_register_capabilities (WAPI_HANDLE_MUTEX,
|
||||
WAPI_HANDLE_CAP_WAIT |
|
||||
WAPI_HANDLE_CAP_SIGNAL |
|
||||
|
||||
@@ -22,7 +22,7 @@ struct _WapiHandle_socket
|
||||
|
||||
struct _WapiHandlePrivate_socket
|
||||
{
|
||||
WapiFDMapped fd_mapped;
|
||||
int fd;
|
||||
};
|
||||
|
||||
#endif /* _WAPI_SOCKET_PRIVATE_H_ */
|
||||
+207
-174
@@ -97,28 +97,21 @@ static void socket_close_private (gpointer handle)
|
||||
|
||||
g_ptr_array_remove_fast(sockets, GUINT_TO_POINTER (handle));
|
||||
|
||||
if (socket_private_handle->fd_mapped.assigned == TRUE) {
|
||||
/* Blank out the mapping, to make catching errors easier */
|
||||
_wapi_handle_fd_offset_store (socket_private_handle->fd_mapped.fd, NULL);
|
||||
|
||||
do {
|
||||
ret=close(socket_private_handle->fd_mapped.fd);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
do {
|
||||
ret=close(socket_private_handle->fd);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
g_message(G_GNUC_PRETTY_FUNCTION ": close error: %s",
|
||||
strerror(errno));
|
||||
g_message(G_GNUC_PRETTY_FUNCTION ": close error: %s",
|
||||
strerror(errno));
|
||||
#endif
|
||||
errnum = errno_to_WSA (errnum, G_GNUC_PRETTY_FUNCTION);
|
||||
WSASetLastError (errnum);
|
||||
errnum = errno_to_WSA (errnum, G_GNUC_PRETTY_FUNCTION);
|
||||
WSASetLastError (errnum);
|
||||
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -212,27 +205,20 @@ int WSAGetLastError(void)
|
||||
return(err);
|
||||
}
|
||||
|
||||
int closesocket(guint32 fd_handle)
|
||||
int closesocket(guint32 handle)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd_handle));
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
WSASetLastError (WSAENOTSOCK);
|
||||
return(0);
|
||||
}
|
||||
|
||||
_wapi_handle_unref (handle);
|
||||
_wapi_handle_unref (GUINT_TO_POINTER (handle));
|
||||
return(0);
|
||||
}
|
||||
|
||||
guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
|
||||
guint32 _wapi_accept(guint32 handle, struct sockaddr *addr,
|
||||
socklen_t *addrlen)
|
||||
{
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
struct _WapiHandlePrivate_socket *new_socket_private_handle;
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
gpointer new_handle;
|
||||
gboolean ok;
|
||||
int new_fd;
|
||||
int fd;
|
||||
int thr_ret;
|
||||
guint32 ret = INVALID_SOCKET;
|
||||
|
||||
@@ -241,18 +227,21 @@ guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
do {
|
||||
new_fd=accept(fd, addr, addrlen);
|
||||
fd=accept(socket_private_handle->fd, addr, addrlen);
|
||||
}
|
||||
while (new_fd==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
while (fd==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
|
||||
if(new_fd==-1) {
|
||||
if(fd==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
g_message(G_GNUC_PRETTY_FUNCTION ": accept error: %s",
|
||||
@@ -265,23 +254,10 @@ guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
if (new_fd >= _wapi_fd_offset_table_size) {
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": File descriptor is too big");
|
||||
#endif
|
||||
|
||||
WSASetLastError (WSASYSCALLFAILURE);
|
||||
|
||||
close (new_fd);
|
||||
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
new_handle=_wapi_handle_new (WAPI_HANDLE_SOCKET);
|
||||
if(new_handle==_WAPI_HANDLE_INVALID) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error creating socket handle");
|
||||
WSASetLastError (ERROR_GEN_FAILURE);
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
@@ -294,21 +270,17 @@ guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen)
|
||||
(gpointer *)&new_socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up new socket handle %p",
|
||||
new_handle);
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
_wapi_handle_fd_offset_store (new_fd, new_handle);
|
||||
ret = new_fd;
|
||||
ret = GPOINTER_TO_UINT (new_handle);
|
||||
|
||||
new_socket_private_handle->fd_mapped.fd = new_fd;
|
||||
new_socket_private_handle->fd_mapped.assigned = TRUE;
|
||||
new_socket_private_handle->fd=fd;
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message(G_GNUC_PRETTY_FUNCTION
|
||||
": returning newly accepted socket handle %p with fd %d",
|
||||
new_handle, new_socket_private_handle->fd_mapped.fd);
|
||||
new_handle, new_socket_private_handle->fd);
|
||||
#endif
|
||||
|
||||
cleanup:
|
||||
@@ -319,23 +291,27 @@ cleanup:
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_bind(guint32 fd, struct sockaddr *my_addr, socklen_t addrlen)
|
||||
int _wapi_bind(guint32 handle, struct sockaddr *my_addr, socklen_t addrlen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
WSASetLastError(WSANOTINITIALISED);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=bind(fd, my_addr, addrlen);
|
||||
ret=bind(socket_private_handle->fd, my_addr, addrlen);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -350,10 +326,11 @@ int _wapi_bind(guint32 fd, struct sockaddr *my_addr, socklen_t addrlen)
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr,
|
||||
int _wapi_connect(guint32 handle, const struct sockaddr *serv_addr,
|
||||
socklen_t addrlen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
gint errnum;
|
||||
|
||||
@@ -362,14 +339,17 @@ int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
do {
|
||||
ret=connect(fd, serv_addr, addrlen);
|
||||
ret=connect(socket_private_handle->fd, serv_addr, addrlen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
|
||||
@@ -381,11 +361,11 @@ int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr,
|
||||
|
||||
errnum = errno;
|
||||
|
||||
ret=setsockopt (fd, SOL_SOCKET, SO_BROADCAST, &true,
|
||||
sizeof(true));
|
||||
ret=setsockopt (socket_private_handle->fd, SOL_SOCKET,
|
||||
SO_BROADCAST, &true, sizeof(true));
|
||||
if(ret==0) {
|
||||
do {
|
||||
ret=connect (fd, serv_addr, addrlen);
|
||||
ret=connect (socket_private_handle->fd, serv_addr, addrlen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
}
|
||||
@@ -406,9 +386,11 @@ int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_getpeername(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
int _wapi_getpeername(guint32 handle, struct sockaddr *name,
|
||||
socklen_t *namelen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -416,13 +398,16 @@ int _wapi_getpeername(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=getpeername(fd, name, namelen);
|
||||
ret=getpeername(socket_private_handle->fd, name, namelen);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -439,9 +424,11 @@ int _wapi_getpeername(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_getsockname(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
int _wapi_getsockname(guint32 handle, struct sockaddr *name,
|
||||
socklen_t *namelen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -449,13 +436,16 @@ int _wapi_getsockname(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=getsockname(fd, name, namelen);
|
||||
ret=getsockname(socket_private_handle->fd, name, namelen);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -472,10 +462,11 @@ int _wapi_getsockname(guint32 fd, struct sockaddr *name, socklen_t *namelen)
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_getsockopt(guint32 fd, int level, int optname, void *optval,
|
||||
int _wapi_getsockopt(guint32 handle, int level, int optname, void *optval,
|
||||
socklen_t *optlen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -483,13 +474,17 @@ int _wapi_getsockopt(guint32 fd, int level, int optname, void *optval,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=getsockopt(fd, level, optname, optval, optlen);
|
||||
ret=getsockopt(socket_private_handle->fd, level, optname, optval,
|
||||
optlen);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -506,9 +501,10 @@ int _wapi_getsockopt(guint32 fd, int level, int optname, void *optval,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_listen(guint32 fd, int backlog)
|
||||
int _wapi_listen(guint32 handle, int backlog)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -516,13 +512,16 @@ int _wapi_listen(guint32 fd, int backlog)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=listen(fd, backlog);
|
||||
ret=listen(socket_private_handle->fd, backlog);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -539,18 +538,19 @@ int _wapi_listen(guint32 fd, int backlog)
|
||||
return(0);
|
||||
}
|
||||
|
||||
int _wapi_recv(guint32 fd, void *buf, size_t len, int recv_flags)
|
||||
int _wapi_recv(guint32 handle, void *buf, size_t len, int recv_flags)
|
||||
{
|
||||
return(_wapi_recvfrom(fd, buf, len, recv_flags, NULL, 0));
|
||||
return(_wapi_recvfrom(handle, buf, len, recv_flags, NULL, 0));
|
||||
}
|
||||
|
||||
int _wapi_recvfrom(guint32 fd, void *buf, size_t len, int recv_flags,
|
||||
int _wapi_recvfrom(guint32 handle, void *buf, size_t len, int recv_flags,
|
||||
struct sockaddr *from, socklen_t *fromlen)
|
||||
{
|
||||
#ifndef HAVE_MSG_NOSIGNAL
|
||||
void (*old_sigpipe)(int); // old SIGPIPE handler
|
||||
#endif
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -558,22 +558,26 @@ int _wapi_recvfrom(guint32 fd, void *buf, size_t len, int recv_flags,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
#ifdef HAVE_MSG_NOSIGNAL
|
||||
do {
|
||||
ret=recvfrom(fd, buf, len, recv_flags | MSG_NOSIGNAL, from,
|
||||
ret=recvfrom(socket_private_handle->fd, buf, len, recv_flags | MSG_NOSIGNAL, from,
|
||||
fromlen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
#else
|
||||
old_sigpipe = signal(SIGPIPE, SIG_IGN);
|
||||
do {
|
||||
ret=recvfrom(fd, buf, len, recv_flags, from, fromlen);
|
||||
ret=recvfrom(socket_private_handle->fd, buf, len, recv_flags, from,
|
||||
fromlen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
signal(SIGPIPE, old_sigpipe);
|
||||
@@ -594,12 +598,13 @@ int _wapi_recvfrom(guint32 fd, void *buf, size_t len, int recv_flags,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_send(guint32 fd, const void *msg, size_t len, int send_flags)
|
||||
int _wapi_send(guint32 handle, const void *msg, size_t len, int send_flags)
|
||||
{
|
||||
#ifndef HAVE_MSG_NOSIGNAL
|
||||
void (*old_sigpipe)(int); // old SIGPIPE handler
|
||||
#endif
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -607,21 +612,24 @@ int _wapi_send(guint32 fd, const void *msg, size_t len, int send_flags)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
#ifdef HAVE_MSG_NOSIGNAL
|
||||
do {
|
||||
ret=send(fd, msg, len, send_flags | MSG_NOSIGNAL);
|
||||
ret=send(socket_private_handle->fd, msg, len, send_flags | MSG_NOSIGNAL);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
#else
|
||||
old_sigpipe = signal(SIGPIPE, SIG_IGN);
|
||||
do {
|
||||
ret=send(fd, msg, len, send_flags);
|
||||
ret=send(socket_private_handle->fd, msg, len, send_flags);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
signal(SIGPIPE, old_sigpipe);
|
||||
@@ -641,13 +649,14 @@ int _wapi_send(guint32 fd, const void *msg, size_t len, int send_flags)
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_sendto(guint32 fd, const void *msg, size_t len, int send_flags,
|
||||
int _wapi_sendto(guint32 handle, const void *msg, size_t len, int send_flags,
|
||||
const struct sockaddr *to, socklen_t tolen)
|
||||
{
|
||||
#ifndef HAVE_MSG_NOSIGNAL
|
||||
void (*old_sigpipe)(int); // old SIGPIPE handler
|
||||
#endif
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -655,21 +664,24 @@ int _wapi_sendto(guint32 fd, const void *msg, size_t len, int send_flags,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
#ifdef HAVE_MSG_NOSIGNAL
|
||||
do {
|
||||
ret=sendto(fd, msg, len, send_flags | MSG_NOSIGNAL, to, tolen);
|
||||
ret=sendto(socket_private_handle->fd, msg, len, send_flags | MSG_NOSIGNAL, to, tolen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
#else
|
||||
old_sigpipe = signal(SIGPIPE, SIG_IGN);
|
||||
do {
|
||||
ret=sendto(fd, msg, len, send_flags, to, tolen);
|
||||
ret=sendto(socket_private_handle->fd, msg, len, send_flags, to, tolen);
|
||||
}
|
||||
while (ret==-1 && errno==EINTR && !_wapi_thread_cur_apc_pending());
|
||||
signal(SIGPIPE, old_sigpipe);
|
||||
@@ -689,10 +701,11 @@ int _wapi_sendto(guint32 fd, const void *msg, size_t len, int send_flags,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_setsockopt(guint32 fd, int level, int optname,
|
||||
int _wapi_setsockopt(guint32 handle, int level, int optname,
|
||||
const void *optval, socklen_t optlen)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -700,13 +713,17 @@ int _wapi_setsockopt(guint32 fd, int level, int optname,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=setsockopt(fd, level, optname, optval, optlen);
|
||||
ret=setsockopt(socket_private_handle->fd, level, optname, optval,
|
||||
optlen);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -723,9 +740,10 @@ int _wapi_setsockopt(guint32 fd, int level, int optname,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
int _wapi_shutdown(guint32 fd, int how)
|
||||
int _wapi_shutdown(guint32 handle, int how)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -733,13 +751,16 @@ int _wapi_shutdown(guint32 fd, int how)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
ret=shutdown(fd, how);
|
||||
ret=shutdown(socket_private_handle->fd, how);
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -781,18 +802,6 @@ guint32 _wapi_socket(int domain, int type, int protocol, void *unused, guint32 u
|
||||
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
if (fd >= _wapi_fd_offset_table_size) {
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION ": File descriptor is too big");
|
||||
#endif
|
||||
|
||||
WSASetLastError (WSASYSCALLFAILURE);
|
||||
close (fd);
|
||||
|
||||
return(INVALID_SOCKET);
|
||||
}
|
||||
|
||||
|
||||
mono_once (&socket_ops_once, socket_ops_init);
|
||||
|
||||
@@ -815,17 +824,14 @@ guint32 _wapi_socket(int domain, int type, int protocol, void *unused, guint32 u
|
||||
": error looking up socket handle %p", handle);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
_wapi_handle_fd_offset_store (fd, handle);
|
||||
ret = fd;
|
||||
ret = GPOINTER_TO_UINT (handle);
|
||||
|
||||
socket_private_handle->fd_mapped.fd = fd;
|
||||
socket_private_handle->fd_mapped.assigned = TRUE;
|
||||
socket_private_handle->fd=fd;
|
||||
|
||||
#ifdef DEBUG
|
||||
g_message(G_GNUC_PRETTY_FUNCTION
|
||||
": returning socket handle %p with fd %d", handle,
|
||||
socket_private_handle->fd_mapped.fd);
|
||||
socket_private_handle->fd);
|
||||
#endif
|
||||
|
||||
cleanup:
|
||||
@@ -878,12 +884,13 @@ struct hostent *_wapi_gethostbyname(const char *hostname)
|
||||
}
|
||||
|
||||
int
|
||||
WSAIoctl (guint32 fd, gint32 command,
|
||||
gchar *input, gint i_len,
|
||||
gchar *output, gint o_len, glong *written,
|
||||
void *unused1, void *unused2)
|
||||
WSAIoctl (guint32 handle, gint32 command,
|
||||
gchar *input, gint i_len,
|
||||
gchar *output, gint o_len, glong *written,
|
||||
void *unused1, void *unused2)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
gchar *buffer = NULL;
|
||||
|
||||
@@ -892,8 +899,12 @@ WSAIoctl (guint32 fd, gint32 command,
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok = _wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
|
||||
if (ok == FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError (WSAENOTSOCK);
|
||||
return SOCKET_ERROR;
|
||||
}
|
||||
@@ -901,7 +912,7 @@ WSAIoctl (guint32 fd, gint32 command,
|
||||
if (i_len > 0)
|
||||
buffer = g_memdup (input, i_len);
|
||||
|
||||
ret = ioctl (fd, command, buffer);
|
||||
ret = ioctl (socket_private_handle->fd, command, buffer);
|
||||
if (ret == -1) {
|
||||
gint errnum = errno;
|
||||
#ifdef DEBUG
|
||||
@@ -930,9 +941,10 @@ WSAIoctl (guint32 fd, gint32 command,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ioctlsocket(guint32 fd, gint32 command, gpointer arg)
|
||||
int ioctlsocket(guint32 handle, gint32 command, gpointer arg)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int ret;
|
||||
|
||||
if(startup_count==0) {
|
||||
@@ -940,8 +952,11 @@ int ioctlsocket(guint32 fd, gint32 command, gpointer arg)
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(SOCKET_ERROR);
|
||||
}
|
||||
@@ -961,19 +976,19 @@ int ioctlsocket(guint32 fd, gint32 command, gpointer arg)
|
||||
* connect to return EINPROGRESS, but the ioctl doesn't seem to)
|
||||
*/
|
||||
if(command==FIONBIO) {
|
||||
ret=fcntl(fd, F_GETFL, 0);
|
||||
ret=fcntl(socket_private_handle->fd, F_GETFL, 0);
|
||||
if(ret!=-1) {
|
||||
if(*(gboolean *)arg) {
|
||||
ret &= ~O_NONBLOCK;
|
||||
} else {
|
||||
ret |= O_NONBLOCK;
|
||||
}
|
||||
ret=fcntl(fd, F_SETFL, ret);
|
||||
ret=fcntl(socket_private_handle->fd, F_SETFL, ret);
|
||||
}
|
||||
} else
|
||||
#endif /* O_NONBLOCK */
|
||||
{
|
||||
ret=ioctl(fd, command, arg);
|
||||
ret=ioctl(socket_private_handle->fd, command, arg);
|
||||
}
|
||||
if(ret==-1) {
|
||||
gint errnum = errno;
|
||||
@@ -1021,43 +1036,55 @@ int _wapi_select(int nfds G_GNUC_UNUSED, fd_set *readfds, fd_set *writefds,
|
||||
return(ret);
|
||||
}
|
||||
|
||||
void _wapi_FD_CLR(guint32 fd, fd_set *set)
|
||||
void _wapi_FD_CLR(guint32 handle, fd_set *set)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return;
|
||||
}
|
||||
|
||||
FD_CLR(fd, set);
|
||||
FD_CLR(socket_private_handle->fd, set);
|
||||
}
|
||||
|
||||
int _wapi_FD_ISSET(guint32 fd, fd_set *set)
|
||||
int _wapi_FD_ISSET(guint32 handle, fd_set *set)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return(0);
|
||||
}
|
||||
|
||||
return(FD_ISSET(fd, set));
|
||||
return(FD_ISSET(socket_private_handle->fd, set));
|
||||
}
|
||||
|
||||
void _wapi_FD_SET(guint32 fd, fd_set *set)
|
||||
void _wapi_FD_SET(guint32 handle, fd_set *set)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (GUINT_TO_POINTER (fd));
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if(ok==FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", handle);
|
||||
WSASetLastError(WSAENOTSOCK);
|
||||
return;
|
||||
}
|
||||
|
||||
FD_SET(fd, set);
|
||||
FD_SET(socket_private_handle->fd, set);
|
||||
}
|
||||
|
||||
#ifdef USE_AIO
|
||||
@@ -1092,23 +1119,29 @@ async_notifier (union sigval sig)
|
||||
}
|
||||
|
||||
static gboolean
|
||||
do_aio_call (gboolean is_read, gpointer fd_handle, gpointer buffer,
|
||||
do_aio_call (gboolean is_read, gpointer handle, gpointer buffer,
|
||||
guint32 numbytes, guint32 *out_bytes,
|
||||
gpointer ares,
|
||||
SocketAsyncCB callback)
|
||||
{
|
||||
gpointer handle = _wapi_handle_fd_offset_to_handle (fd_handle);
|
||||
int fd = GPOINTER_TO_UINT (fd_handle);
|
||||
struct _WapiHandlePrivate_socket *socket_private_handle;
|
||||
gboolean ok;
|
||||
int fd;
|
||||
struct aiocb *aio;
|
||||
int result;
|
||||
notifier_data_t *ndata;
|
||||
|
||||
if (handle == NULL ||
|
||||
_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) {
|
||||
ok=_wapi_lookup_handle (GUINT_TO_POINTER (handle), WAPI_HANDLE_SOCKET,
|
||||
NULL, (gpointer *)&socket_private_handle);
|
||||
if (ok == FALSE) {
|
||||
g_warning (G_GNUC_PRETTY_FUNCTION
|
||||
": error looking up socket handle 0x%x", (guint) handle);
|
||||
WSASetLastError (WSAENOTSOCK);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
fd = socket_private_handle->fd;
|
||||
|
||||
ndata = g_new0 (notifier_data_t, 1);
|
||||
aio = g_new0 (struct aiocb, 1);
|
||||
ndata->ares = ares;
|
||||
|
||||
@@ -99,7 +99,9 @@ static void thread_close_private (gpointer handle)
|
||||
thread_handle->thread->id);
|
||||
#endif
|
||||
|
||||
thread_handle->thread=NULL;
|
||||
if(thread_handle->thread!=NULL) {
|
||||
_wapi_timed_thread_destroy (thread_handle->thread);
|
||||
}
|
||||
}
|
||||
|
||||
static void thread_own (gpointer handle)
|
||||
@@ -626,10 +628,6 @@ guint32 ResumeThread(gpointer handle)
|
||||
return(0xFFFFFFFF);
|
||||
}
|
||||
|
||||
if (thread_private_handle->thread == NULL) {
|
||||
return(0xFFFFFFFF);
|
||||
}
|
||||
|
||||
#ifdef WITH_INCLUDED_LIBGC
|
||||
if (thread_private_handle->thread->suspend_count <= 1)
|
||||
_wapi_timed_thread_resume (thread_private_handle->thread);
|
||||
@@ -672,10 +670,6 @@ guint32 SuspendThread(gpointer handle)
|
||||
return(0xFFFFFFFF);
|
||||
}
|
||||
|
||||
if (thread_private_handle->thread == NULL) {
|
||||
return(0xFFFFFFFF);
|
||||
}
|
||||
|
||||
if (!thread_private_handle->thread->suspend_count) {
|
||||
if (handle == current)
|
||||
_wapi_timed_thread_suspend (thread_private_handle->thread);
|
||||
|
||||
@@ -254,8 +254,6 @@ int _wapi_timed_thread_join(TimedThread *thread, struct timespec *timeout,
|
||||
if(exitstatus!=NULL) {
|
||||
*exitstatus = thread->exitstatus;
|
||||
}
|
||||
|
||||
_wapi_timed_thread_destroy (thread);
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
@@ -354,15 +354,9 @@ static gboolean test_and_own (guint32 numobjects, gpointer *handles,
|
||||
done = _wapi_handle_count_signalled_handles (numobjects, handles,
|
||||
waitall, count, lowest);
|
||||
if (done == TRUE) {
|
||||
if (waitall == TRUE) {
|
||||
for (i = 0; i < numobjects; i++) {
|
||||
if (_wapi_handle_issignalled (handles[i])) {
|
||||
_wapi_handle_ops_own (handles[i]);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (_wapi_handle_issignalled (handles[*lowest])) {
|
||||
_wapi_handle_ops_own (handles[*lowest]);
|
||||
for (i = 0; i < numobjects; i++) {
|
||||
if (_wapi_handle_issignalled (handles[i])) {
|
||||
_wapi_handle_ops_own (handles[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,7 +35,7 @@
|
||||
/* Increment this whenever an incompatible change is made to the
|
||||
* shared handle structure.
|
||||
*/
|
||||
#define _WAPI_HANDLE_VERSION 3
|
||||
#define _WAPI_HANDLE_VERSION 1
|
||||
|
||||
typedef enum {
|
||||
WAPI_HANDLE_UNUSED=0,
|
||||
@@ -59,19 +59,6 @@ typedef struct
|
||||
guint32 name;
|
||||
} WapiSharedNamespace;
|
||||
|
||||
/* The boolean is for distinguishing between a zeroed struct being not
|
||||
* as yet assigned, and one containing a valid fd 0. It's also used
|
||||
* to signal that a previously-good fd has been reused behind our
|
||||
* back, so we need to invalidate the handle that thought it owned the
|
||||
* fd.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
int fd;
|
||||
gboolean assigned;
|
||||
} WapiFDMapped;
|
||||
|
||||
|
||||
typedef enum {
|
||||
WAPI_HANDLE_CAP_WAIT=0x01,
|
||||
WAPI_HANDLE_CAP_SIGNAL=0x02,
|
||||
@@ -165,7 +152,6 @@ struct _WapiHandleShared_list
|
||||
{
|
||||
guchar daemon[MONO_SIZEOF_SUNPATH];
|
||||
_wapi_daemon_status daemon_running;
|
||||
guint32 fd_offset_table_size;
|
||||
|
||||
#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
|
||||
mono_mutex_t signal_mutex;
|
||||
|
||||
+1
-205
@@ -1,208 +1,3 @@
|
||||
2004-10-02 Ben Maurer <[email protected]>
|
||||
|
||||
* threadpool.c: the ares hashtable needs a critical section around it.
|
||||
this prevents some nasty segfaults
|
||||
|
||||
2004-09-30 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* threads.c: don't call mono_thread_detach() in start_wrapper(),
|
||||
avoiding a possible hang in GetCurrentThreadId(0). Fixes bug #65379.
|
||||
|
||||
2004-09-28 Zoltan Varga <[email protected]>
|
||||
|
||||
* reflection.c (method_encode_code): Align method headers properly.
|
||||
Fixes #66025.
|
||||
|
||||
2004-09-25 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* threadpool.c: reuse allocated slots in the queue.
|
||||
|
||||
2004-09-23 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* appdomain.c:
|
||||
(mono_domain_set): allow setting a domain that is being unloaded.
|
||||
(mono_domain_unload): invoke the DomainUnload callbacks in the domain
|
||||
being unloaded.
|
||||
|
||||
2004-09-18 Martin Baulig <[email protected]>
|
||||
|
||||
* mono-debug.c, debug-mono-symfile.c: Merged my locking changes
|
||||
from HEAD.
|
||||
|
||||
2004-09-17 Zoltan Varga <[email protected]>
|
||||
|
||||
* loader.c (mono_lookup_pinvoke_call): Add support for stdcall name
|
||||
mangling.
|
||||
|
||||
2004-09-16 Lluis Sanchez Gual <[email protected]>
|
||||
|
||||
* locales.c: nullify the ICU_collator member of CompareInfo when it is
|
||||
finalized. There where random SIGSEVs at program termination, when
|
||||
an object being finalized was trying to do a string comparison and
|
||||
the current culture was already finalized.
|
||||
|
||||
2004-09-16 Zoltan Varga <[email protected]>
|
||||
|
||||
* appdomain.c (ves_icall_System_AppDomain_createDomain): Load all
|
||||
assemblies from the parent. Fixes #65665.
|
||||
|
||||
2004-09-14 Lluis Sanchez Gual <[email protected]>
|
||||
|
||||
* object.c: Added a "done" flag to TypeInitializationLock. This avoids
|
||||
false deadlock checks in class initialization.
|
||||
|
||||
2004-09-09 Zoltan Varga <[email protected]>
|
||||
|
||||
* reflection.h reflection.c loader.c: Allow dynamic construction of
|
||||
pinvoke methods. Fixes #65571.
|
||||
|
||||
2004-09-08 Lluis Sanchez Gual <[email protected]>
|
||||
|
||||
* object.c: In mono_message_invoke, fill the output parameter array after
|
||||
calling the managed method (it was done before the call). This fixes
|
||||
bug #59299.
|
||||
|
||||
2004-09-08 Zoltan Varga <[email protected]>
|
||||
|
||||
* image.c (mono_image_close): Applied patch from
|
||||
[email protected] (Vasantha selvi). Fix crash when an
|
||||
assembly is loaded multiple times from data.
|
||||
|
||||
* image.c (mono_image_open): Fix warning.
|
||||
|
||||
2004-09-07 Zoltan Varga <[email protected]>
|
||||
|
||||
* reflection.c (mono_reflection_create_runtime_class): Initialize
|
||||
klass->nested_classes. Fixes #61224.
|
||||
|
||||
2004-09-06 Zoltan Varga <[email protected]>
|
||||
|
||||
* reflection.c (mono_param_get_objects): Initialize the default value
|
||||
with DBNull.Value, not null. Fixes #62123.
|
||||
|
||||
2004-09-01 Miguel de Icaza <[email protected]>
|
||||
|
||||
* marshal.c (mono_marshal_get_managed_wrapper): Remove FIXME and
|
||||
throw an exception with a cute explanation.
|
||||
|
||||
2004-09-06 Dick Porter <[email protected]>
|
||||
|
||||
* process.c (ves_icall_System_Diagnostics_Process_Start_internal):
|
||||
Close the new process's thread handle, as we don't use it. The
|
||||
handle stays around forever otherwise.
|
||||
|
||||
2004-09-05 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* assembly.c: provide more information when loading an assembly fails.
|
||||
|
||||
2004-09-04 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* filewatcher.c: don't expect the development fam package to be
|
||||
installed. If HAVE_KQUEUE return mode 3 to use the new kqueue
|
||||
watcher. Patch by Geoff Norton.
|
||||
|
||||
2004-09-02 Zoltan Varga <[email protected]>
|
||||
|
||||
* marshal.c (mono_marshal_alloc): Return a valid pointer on size 0
|
||||
as well.
|
||||
|
||||
2004-08-28 Ben Maurer <[email protected]>
|
||||
|
||||
* gc.c: actually enable paolo's patch to make GC warnings
|
||||
use the trace api.
|
||||
|
||||
2004-08-23 Zoltan Varga <[email protected]>
|
||||
|
||||
* metadata.c (mono_metadata_parse_type): Alloc pinned, byref and
|
||||
custom modifiers to be in any order. Fixes #61990.
|
||||
|
||||
Thu Aug 5 17:11:44 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* reflection.c: fix to deal with object[] arrays in custom ctors
|
||||
(bug #62550).
|
||||
|
||||
Tue Aug 3 17:54:17 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* gc.c: make GC warning messages use the trace API, they are just
|
||||
noise to most of the users.
|
||||
|
||||
Tue Aug 3 16:40:17 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* gc.c, object.h: mono_gc_handle_*() interface and
|
||||
AddrOfPinnedObject fixes. GC handle support even without GC.
|
||||
|
||||
Fri Jul 30 16:49:05 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* object.c: always create an object if null is passed
|
||||
to Invoke() where a valuetype is expected.
|
||||
|
||||
2004-07-29 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* appdomain.c: hack to build correctly the private bin path on windows.
|
||||
Fixes bug #61991.
|
||||
|
||||
2004-07-28 Dick Porter <[email protected]>
|
||||
|
||||
* socket-io.c
|
||||
(ves_icall_System_Net_Sockets_Socket_RecvFrom_internal): Check
|
||||
returned sockaddr size before creating the remote address object.
|
||||
Patch by Nick Vaughan ([email protected]), fixes bug
|
||||
61608.
|
||||
|
||||
2004-07-28 Dick Porter <[email protected]>
|
||||
|
||||
* locales.c (string_invariant_compare_char): Fix invariant char
|
||||
compares between upper and lower cases. Fixes bug 61458.
|
||||
|
||||
Tue Jul 27 15:58:19 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* debug-mono-symfile.c: fix one more endianess issue, from a patch
|
||||
by Geoff Norton (<[email protected]>).
|
||||
|
||||
Tue Jul 27 15:47:17 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* class.c: fix class loads for pointer types (typeof(int) !=
|
||||
typeof(int*)).
|
||||
|
||||
2004-07-24 Martin Baulig <[email protected]>
|
||||
|
||||
* reflection.c (mono_image_get_type_info): Only write a class
|
||||
layout entry if we actually have a size or a packing size.
|
||||
|
||||
2004-07-13 Peter Williams <[email protected]>
|
||||
|
||||
* process.c (complete_path): Make sure we don't attempt to execute
|
||||
directories.
|
||||
|
||||
2004-07-11 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* debug-helpers.c: undo my previous patch and fixed the real issue in
|
||||
../mini/exceptions-x86.c
|
||||
|
||||
2004-07-11 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* debug-helpers.c: prevent SIGSEGV. It happened running xsp on monodoc
|
||||
when no HOME env. variable was set and a NullRef was thrown in a .cctor
|
||||
called from other .cctors.
|
||||
|
||||
2004-07-09 Dick Porter <[email protected]>
|
||||
|
||||
* locales.c (ves_icall_System_String_InternalReplace_Str_Comp):
|
||||
Don't do any more processing if the matched length was 0. It was
|
||||
increasing the size of the string before. Fixes bug 61167.
|
||||
|
||||
2004-07-09 Dick Porter <[email protected]>
|
||||
|
||||
* socket-io.h:
|
||||
* socket-io.c
|
||||
(ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal):
|
||||
Add support for SO_PEERCRED if its available.
|
||||
|
||||
2004-07-03 Zoltan Varga <[email protected]>
|
||||
|
||||
* marshal.c: Fix managed->native stringbuilder marshalling. Implement
|
||||
marshalling of stringbuilder arrays. Fixes #59900.
|
||||
|
||||
2004-06-29 Martin Baulig <[email protected]>
|
||||
|
||||
* mono-debug.c (mono_debug_add_method): Protect the whole function
|
||||
@@ -11118,3 +10913,4 @@ Tue Jul 3 18:33:32 CEST 2001 Paolo Molaro <[email protected]>
|
||||
Beta2.
|
||||
|
||||
* mono/metadata/assembly.c (load_metadata_ptrs): Fix for Beta2
|
||||
|
||||
+12
-34
@@ -44,9 +44,6 @@ mono_domain_assembly_preload (MonoAssemblyName *aname,
|
||||
static void
|
||||
mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
|
||||
|
||||
static void
|
||||
add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass);
|
||||
|
||||
static MonoMethod *
|
||||
look_for_method_by_name (MonoClass *klass, const gchar *name);
|
||||
|
||||
@@ -252,12 +249,12 @@ mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
|
||||
* if it is being unloaded.
|
||||
* Returns:
|
||||
* - TRUE on success
|
||||
* - FALSE if the domain is unloaded
|
||||
* - FALSE if the domain is being unloaded
|
||||
*/
|
||||
gboolean
|
||||
mono_domain_set (MonoDomain *domain, gboolean force)
|
||||
{
|
||||
if (!force && domain->state == MONO_APPDOMAIN_UNLOADED)
|
||||
if (!force && (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED))
|
||||
return FALSE;
|
||||
|
||||
mono_domain_set_internal (domain);
|
||||
@@ -360,16 +357,10 @@ ves_icall_System_AppDomain_getCurDomain ()
|
||||
return add->domain;
|
||||
}
|
||||
|
||||
static void
|
||||
add_assembly_to_domain (gpointer key, gpointer value, gpointer user_data)
|
||||
{
|
||||
add_assemblies_to_domain ((MonoDomain*)user_data, (MonoAssembly*)value);
|
||||
}
|
||||
|
||||
MonoAppDomain *
|
||||
ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
|
||||
{
|
||||
MonoDomain *domain = mono_domain_get ();
|
||||
/*MonoDomain *domain = mono_domain_get (); */
|
||||
MonoClass *adclass;
|
||||
MonoAppDomain *ad;
|
||||
MonoDomain *data;
|
||||
@@ -390,10 +381,7 @@ ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomai
|
||||
|
||||
mono_context_init (data);
|
||||
|
||||
/* The new appdomain should have all assemblies loaded */
|
||||
mono_domain_lock (domain);
|
||||
g_hash_table_foreach (domain->assemblies, add_assembly_to_domain, data);
|
||||
mono_domain_unlock (domain);
|
||||
/* FIXME: what to do next ? */
|
||||
|
||||
return ad;
|
||||
}
|
||||
@@ -559,17 +547,9 @@ reduce_path (const gchar *dirname)
|
||||
for (tmp = list; tmp; tmp = tmp->next) {
|
||||
gchar *data = (gchar *) tmp->data;
|
||||
|
||||
if (data && *data) {
|
||||
#ifdef PLATFORM_WIN32
|
||||
if (result->len == 0)
|
||||
g_string_append_printf (result, "%s\\", data);
|
||||
else if (result->str [result->len - 1] == '\\')
|
||||
g_string_append_printf (result, "%s", data);
|
||||
else
|
||||
#endif
|
||||
g_string_append_printf (result, "%c%s",
|
||||
G_DIR_SEPARATOR, data);
|
||||
}
|
||||
if (data && *data)
|
||||
g_string_append_printf (result, "%c%s", G_DIR_SEPARATOR,
|
||||
(char *) tmp->data);
|
||||
}
|
||||
|
||||
res = result->str;
|
||||
@@ -1020,8 +1000,10 @@ ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
|
||||
assembly = mono_assembly_open (filename, NULL);
|
||||
g_free (filename);
|
||||
|
||||
if (!assembly)
|
||||
mono_raise_exception (mono_get_exception_file_not_found (filename));
|
||||
if (!assembly) {
|
||||
mono_raise_exception ((MonoException *)mono_exception_from_name (
|
||||
mono_defaults.corlib, "System.IO", "FileNotFoundException"));
|
||||
}
|
||||
|
||||
image = assembly->image;
|
||||
|
||||
@@ -1130,7 +1112,7 @@ ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
|
||||
MONO_ARCH_SAVE_REGS;
|
||||
|
||||
mono_context_set (mc);
|
||||
|
||||
|
||||
return old_context;
|
||||
}
|
||||
|
||||
@@ -1233,7 +1215,6 @@ mono_domain_unload (MonoDomain *domain)
|
||||
MonoMethod *method;
|
||||
MonoObject *exc;
|
||||
unload_data thread_data;
|
||||
MonoDomain *caller_domain = mono_domain_get ();
|
||||
|
||||
/* printf ("UNLOAD STARTING FOR %s.\n", domain->friendly_name); */
|
||||
|
||||
@@ -1251,7 +1232,6 @@ mono_domain_unload (MonoDomain *domain)
|
||||
g_assert_not_reached ();
|
||||
}
|
||||
|
||||
mono_domain_set (domain, FALSE);
|
||||
/* Notify OnDomainUnload listeners */
|
||||
method = look_for_method_by_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload");
|
||||
g_assert (method);
|
||||
@@ -1261,7 +1241,6 @@ mono_domain_unload (MonoDomain *domain)
|
||||
if (exc) {
|
||||
/* Roll back the state change */
|
||||
domain->state = MONO_APPDOMAIN_CREATED;
|
||||
mono_domain_set (caller_domain, FALSE);
|
||||
mono_raise_exception ((MonoException*)exc);
|
||||
}
|
||||
|
||||
@@ -1288,7 +1267,6 @@ mono_domain_unload (MonoDomain *domain)
|
||||
; /* wait for the thread */
|
||||
|
||||
|
||||
mono_domain_set (caller_domain, FALSE);
|
||||
if (thread_data.failure_reason) {
|
||||
MonoException *ex;
|
||||
|
||||
|
||||
@@ -388,15 +388,6 @@ mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status)
|
||||
image->name, aname.name);
|
||||
|
||||
} else {
|
||||
char *extra_msg = g_strdup ("");
|
||||
|
||||
if (*status == MONO_IMAGE_ERROR_ERRNO) {
|
||||
extra_msg = g_strdup_printf ("System error: %s\n", strerror (errno));
|
||||
} else if (*status == MONO_IMAGE_MISSING_ASSEMBLYREF) {
|
||||
extra_msg = g_strdup ("Cannot find an assembly referenced from this one.\n");
|
||||
} else if (*status == MONO_IMAGE_IMAGE_INVALID) {
|
||||
extra_msg = g_strdup ("The file exists but is not a valid assembly.\n");
|
||||
}
|
||||
|
||||
for (j = 0; j < i; j++)
|
||||
mono_assembly_close (references [j]);
|
||||
@@ -405,12 +396,11 @@ mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status)
|
||||
g_warning ("Could not find assembly %s, references from %s (assemblyref_index=%d)\n"
|
||||
" Major/Minor: %d,%d\n"
|
||||
" Build: %d,%d\n"
|
||||
" Token: %s\n%s",
|
||||
" Token: %s\n",
|
||||
aname.name, image->name, i,
|
||||
aname.major, aname.minor, aname.build, aname.revision,
|
||||
aname.public_key_token, extra_msg);
|
||||
aname.public_key_token);
|
||||
*status = MONO_IMAGE_MISSING_ASSEMBLYREF;
|
||||
g_free (extra_msg);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2124,7 +2124,7 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec,
|
||||
class = mono_array_class_get (type->data.klass, 1);
|
||||
break;
|
||||
case MONO_TYPE_PTR:
|
||||
class = mono_ptr_class_get (type->data.type);
|
||||
class = mono_class_from_mono_type (type->data.type);
|
||||
break;
|
||||
case MONO_TYPE_GENERICINST:
|
||||
g_assert (type->data.generic_inst->klass);
|
||||
|
||||
@@ -107,21 +107,17 @@ mono_debug_open_mono_symbol_file (MonoDebugHandle *handle, gboolean create_symfi
|
||||
{
|
||||
MonoSymbolFile *symfile;
|
||||
|
||||
mono_loader_lock ();
|
||||
symfile = g_new0 (MonoSymbolFile, 1);
|
||||
|
||||
symfile->raw_contents = open_symfile (handle->image, &symfile->raw_contents_size);
|
||||
|
||||
if (load_symfile (handle, symfile)) {
|
||||
mono_loader_unlock ();
|
||||
if (load_symfile (handle, symfile))
|
||||
return symfile;
|
||||
} else if (!create_symfile) {
|
||||
else if (!create_symfile) {
|
||||
mono_debug_close_mono_symbol_file (symfile);
|
||||
mono_loader_unlock ();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mono_loader_unlock ();
|
||||
return symfile;
|
||||
}
|
||||
|
||||
@@ -131,18 +127,16 @@ mono_debug_close_mono_symbol_file (MonoSymbolFile *symfile)
|
||||
if (!symfile)
|
||||
return;
|
||||
|
||||
mono_loader_lock ();
|
||||
if (symfile->method_hash)
|
||||
g_hash_table_destroy (symfile->method_hash);
|
||||
|
||||
g_free (symfile);
|
||||
mono_loader_unlock ();
|
||||
}
|
||||
|
||||
static gchar *
|
||||
read_string (const char *ptr)
|
||||
{
|
||||
int len = read32 (ptr);
|
||||
int len = *((guint32 *) ptr);
|
||||
ptr += sizeof(guint32);
|
||||
return g_filename_from_utf8 (ptr, len, NULL, NULL, NULL);
|
||||
}
|
||||
@@ -157,17 +151,12 @@ mono_debug_find_source_location (MonoSymbolFile *symfile, MonoMethod *method, gu
|
||||
const char *ptr;
|
||||
int i;
|
||||
|
||||
mono_loader_lock ();
|
||||
if (!symfile->method_hash) {
|
||||
mono_loader_unlock ();
|
||||
if (!symfile->method_hash)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
minfo = g_hash_table_lookup (symfile->method_hash, method);
|
||||
if (!minfo) {
|
||||
mono_loader_unlock ();
|
||||
if (!minfo)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (read32(&(minfo->entry->_source_index))) {
|
||||
int offset = read32(&(symfile->offset_table->_source_table_offset)) +
|
||||
@@ -187,7 +176,6 @@ mono_debug_find_source_location (MonoSymbolFile *symfile, MonoMethod *method, gu
|
||||
|
||||
if (line_number) {
|
||||
*line_number = read32(&(lne->_row));
|
||||
mono_loader_unlock ();
|
||||
if (source_file)
|
||||
return source_file;
|
||||
else
|
||||
@@ -195,16 +183,11 @@ mono_debug_find_source_location (MonoSymbolFile *symfile, MonoMethod *method, gu
|
||||
} else if (source_file) {
|
||||
gchar *retval = g_strdup_printf ("%s:%d", source_file, read32(&(lne->_row)));
|
||||
g_free (source_file);
|
||||
mono_loader_unlock ();
|
||||
return retval;
|
||||
} else {
|
||||
gchar* retval = g_strdup_printf ("%d", read32(&(lne->_row)));
|
||||
mono_loader_unlock ();
|
||||
return retval;
|
||||
}
|
||||
} else
|
||||
return g_strdup_printf ("%d", read32(&(lne->_row)));
|
||||
}
|
||||
|
||||
mono_loader_unlock ();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -250,7 +233,6 @@ mono_debug_find_method (MonoDebugHandle *handle, MonoMethod *method)
|
||||
if (handle->image != mono_class_get_image (mono_method_get_class (method)))
|
||||
return NULL;
|
||||
|
||||
mono_loader_lock ();
|
||||
first_ie = (MonoSymbolFileMethodIndexEntry *)
|
||||
(symfile->raw_contents + read32(&(symfile->offset_table->_method_table_offset)));
|
||||
|
||||
@@ -258,10 +240,8 @@ mono_debug_find_method (MonoDebugHandle *handle, MonoMethod *method)
|
||||
read32(&(symfile->offset_table->_method_count)),
|
||||
sizeof (MonoSymbolFileMethodIndexEntry), compare_method);
|
||||
|
||||
if (!ie) {
|
||||
mono_loader_unlock ();
|
||||
if (!ie)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
me = (MonoSymbolFileMethodEntry *) (symfile->raw_contents + read32(&(ie->_file_offset)));
|
||||
|
||||
@@ -276,6 +256,5 @@ mono_debug_find_method (MonoDebugHandle *handle, MonoMethod *method)
|
||||
|
||||
g_hash_table_insert (symfile->method_hash, method, minfo);
|
||||
|
||||
mono_loader_unlock ();
|
||||
return minfo;
|
||||
}
|
||||
@@ -89,26 +89,21 @@ static int (*FAMNextEvent) (gpointer, gpointer);
|
||||
gint
|
||||
ves_icall_System_IO_FSW_SupportsFSW (void)
|
||||
{
|
||||
#if HAVE_KQUEUE
|
||||
return 3;
|
||||
#else
|
||||
GModule *fam_module;
|
||||
gchar *filename;
|
||||
|
||||
MONO_ARCH_SAVE_REGS;
|
||||
|
||||
filename = g_module_build_path (NULL, "libfam.so.0");
|
||||
fam_module = g_module_open (filename, G_MODULE_BIND_LAZY);
|
||||
g_free (filename);
|
||||
if (fam_module == NULL)
|
||||
fam_module = g_module_open ("libfam", G_MODULE_BIND_LAZY);
|
||||
if (fam_module == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
g_module_symbol (fam_module, "FAMNextEvent", (gpointer *) &FAMNextEvent);
|
||||
if (FAMNextEvent == NULL)
|
||||
return 0;
|
||||
|
||||
return 2;
|
||||
#endif
|
||||
}
|
||||
|
||||
gpointer
|
||||
|
||||
+12
-60
@@ -16,7 +16,6 @@
|
||||
#include <mono/metadata/exception.h>
|
||||
#include <mono/metadata/domain-internals.h>
|
||||
#include <mono/metadata/class-internals.h>
|
||||
#include <mono/utils/mono-logger.h>
|
||||
#define GC_I_HIDE_POINTERS
|
||||
#include <mono/os/gc_wrapper.h>
|
||||
|
||||
@@ -348,17 +347,13 @@ ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint
|
||||
/* Indexes start from 1 since 0 means the handle is not allocated */
|
||||
idx = ++next_handle;
|
||||
if (idx >= array_size) {
|
||||
#if HAVE_BOEHM_GC
|
||||
gpointer *new_array;
|
||||
guint8 *new_type_array;
|
||||
if (!array_size)
|
||||
array_size = 16;
|
||||
#if HAVE_BOEHM_GC
|
||||
new_array = GC_MALLOC (sizeof (gpointer) * (array_size * 2));
|
||||
new_type_array = GC_MALLOC (sizeof (guint8) * (array_size * 2));
|
||||
#else
|
||||
new_array = g_malloc0 (sizeof (gpointer) * (array_size * 2));
|
||||
new_type_array = g_malloc0 (sizeof (guint8) * (array_size * 2));
|
||||
#endif
|
||||
if (gc_handles) {
|
||||
int i;
|
||||
memcpy (new_array, gc_handles, sizeof (gpointer) * array_size);
|
||||
@@ -375,22 +370,20 @@ ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint
|
||||
#else
|
||||
if (((gulong)new_array [i]) & 0x1) {
|
||||
#endif
|
||||
#if HAVE_BOEHM_GC
|
||||
if (gc_handles [i] != (gpointer)-1)
|
||||
GC_unregister_disappearing_link (&(gc_handles [i]));
|
||||
if (new_array [i] != (gpointer)-1)
|
||||
GC_GENERAL_REGISTER_DISAPPEARING_LINK (&(new_array [i]), REVEAL_POINTER (new_array [i]));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
array_size *= 2;
|
||||
#ifndef HAVE_BOEHM_GC
|
||||
g_free (gc_handles);
|
||||
g_free (gc_handle_types);
|
||||
#endif
|
||||
gc_handles = new_array;
|
||||
gc_handle_types = new_type_array;
|
||||
#else
|
||||
LeaveCriticalSection (&handle_section);
|
||||
mono_raise_exception (mono_get_exception_execution_engine ("No GCHandle support built-in"));
|
||||
#endif
|
||||
}
|
||||
|
||||
/* resuse the type from the old target */
|
||||
@@ -406,6 +399,9 @@ ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint
|
||||
#if HAVE_BOEHM_GC
|
||||
if (gc_handles [idx] != (gpointer)-1)
|
||||
GC_GENERAL_REGISTER_DISAPPEARING_LINK (&(gc_handles [idx]), obj);
|
||||
#else
|
||||
LeaveCriticalSection (&handle_section);
|
||||
mono_raise_exception (mono_get_exception_execution_engine ("No weakref support"));
|
||||
#endif
|
||||
break;
|
||||
default:
|
||||
@@ -433,6 +429,9 @@ ves_icall_System_GCHandle_FreeHandle (guint32 handle)
|
||||
if (gc_handles [idx] != (gpointer)-1)
|
||||
GC_unregister_disappearing_link (&(gc_handles [idx]));
|
||||
}
|
||||
#else
|
||||
LeaveCriticalSection (&handle_section);
|
||||
mono_raise_exception (mono_get_exception_execution_engine ("No GCHandle support"));
|
||||
#endif
|
||||
|
||||
gc_handles [idx] = (gpointer)-1;
|
||||
@@ -458,50 +457,11 @@ ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle)
|
||||
if (obj == (MonoObject *) -1)
|
||||
return NULL;
|
||||
}
|
||||
if (obj) {
|
||||
MonoClass *klass = mono_object_class (obj);
|
||||
if (klass == mono_defaults.string_class) {
|
||||
return mono_string_chars ((MonoString*)obj);
|
||||
} else if (klass->rank) {
|
||||
return mono_array_addr ((MonoArray*)obj, char, 0);
|
||||
} else {
|
||||
/* the C# code will check and throw the exception */
|
||||
/* FIXME: missing !klass->blittable test, see bug #61134,
|
||||
* disabled in 1.0 untill the blittable-using code is audited.
|
||||
if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
|
||||
return (gpointer)-1; */
|
||||
return (char*)obj + sizeof (MonoObject);
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
guint32
|
||||
mono_gchandle_new (MonoObject *obj, gboolean pinned)
|
||||
{
|
||||
return ves_icall_System_GCHandle_GetTargetHandle (obj, 0, pinned? HANDLE_PINNED: HANDLE_NORMAL);
|
||||
}
|
||||
|
||||
guint32
|
||||
mono_gchandle_new_weakref (MonoObject *obj, gboolean track_resurrection)
|
||||
{
|
||||
return ves_icall_System_GCHandle_GetTargetHandle (obj, 0, track_resurrection? HANDLE_WEAK_TRACK: HANDLE_WEAK);
|
||||
}
|
||||
|
||||
/* This will return NULL for a collected object if using a weakref handle */
|
||||
MonoObject*
|
||||
mono_gchandle_get_target (guint32 gchandle)
|
||||
{
|
||||
return ves_icall_System_GCHandle_GetTarget (gchandle);
|
||||
}
|
||||
|
||||
void
|
||||
mono_gchandle_free (guint32 gchandle)
|
||||
{
|
||||
ves_icall_System_GCHandle_FreeHandle (gchandle);
|
||||
}
|
||||
|
||||
#if HAVE_BOEHM_GC
|
||||
|
||||
static HANDLE finalizer_event;
|
||||
@@ -646,12 +606,6 @@ static GCThreadFunctions mono_gc_thread_vtable = {
|
||||
};
|
||||
#endif /* WITH_INCLUDED_LIBGC */
|
||||
|
||||
static void
|
||||
mono_gc_warning (char *msg, GC_word arg)
|
||||
{
|
||||
mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_GC, msg, (unsigned long)arg);
|
||||
}
|
||||
|
||||
void mono_gc_init (void)
|
||||
{
|
||||
InitializeCriticalSection (&handle_section);
|
||||
@@ -663,8 +617,6 @@ void mono_gc_init (void)
|
||||
gc_thread_vtable = &mono_gc_thread_vtable;
|
||||
#endif
|
||||
|
||||
GC_set_warn_proc (mono_gc_warning);
|
||||
|
||||
#ifdef ENABLE_FINALIZER_THREAD
|
||||
|
||||
if (g_getenv ("GC_DONT_GC")) {
|
||||
|
||||
+4
-17
@@ -849,12 +849,12 @@ MonoImage *
|
||||
mono_image_open (const char *fname, MonoImageOpenStatus *status)
|
||||
{
|
||||
MonoImage *image, *image2;
|
||||
char *absfname;
|
||||
const char *absfname;
|
||||
|
||||
g_return_val_if_fail (fname != NULL, NULL);
|
||||
|
||||
if (g_path_is_absolute (fname))
|
||||
absfname = (char*)fname;
|
||||
absfname = fname;
|
||||
else {
|
||||
gchar *path = g_get_current_dir ();
|
||||
absfname = g_build_filename (path, fname, NULL);
|
||||
@@ -960,22 +960,9 @@ mono_image_close (MonoImage *image)
|
||||
|
||||
if (image->f)
|
||||
fclose (image->f);
|
||||
if (image->raw_data_allocated) {
|
||||
/* image->raw_metadata and cli_sections might lie inside image->raw_data */
|
||||
MonoCLIImageInfo *ii = image->image_info;
|
||||
int i;
|
||||
|
||||
if ((image->raw_metadata > image->raw_data) &&
|
||||
(image->raw_metadata <= (image->raw_data + image->raw_data_len)))
|
||||
image->raw_metadata = NULL;
|
||||
|
||||
for (i = 0; i < ii->cli_section_count; i++)
|
||||
if (((char*)(ii->cli_sections [i]) > image->raw_data) &&
|
||||
((char*)(ii->cli_sections [i]) <= ((char*)image->raw_data + image->raw_data_len)))
|
||||
ii->cli_sections [i] = NULL;
|
||||
|
||||
if (image->raw_data_allocated)
|
||||
g_free (image->raw_data);
|
||||
}
|
||||
|
||||
g_free (image->name);
|
||||
g_free (image->files);
|
||||
|
||||
|
||||
+13
-41
@@ -580,41 +580,28 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char
|
||||
|
||||
g_assert (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
|
||||
|
||||
if (exc_class) {
|
||||
*exc_class = NULL;
|
||||
*exc_arg = NULL;
|
||||
}
|
||||
|
||||
if (method->addr)
|
||||
return method->addr;
|
||||
if (!piinfo->implmap_idx)
|
||||
return NULL;
|
||||
|
||||
mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
|
||||
|
||||
if (method->klass->image->dynamic) {
|
||||
MonoReflectionMethodAux *method_aux =
|
||||
mono_g_hash_table_lookup (
|
||||
((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
|
||||
if (!method_aux)
|
||||
return NULL;
|
||||
|
||||
import = method_aux->dllentry;
|
||||
orig_scope = method_aux->dll;
|
||||
}
|
||||
else {
|
||||
if (!piinfo->implmap_idx)
|
||||
return NULL;
|
||||
|
||||
mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
|
||||
|
||||
piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
|
||||
import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
|
||||
scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
|
||||
orig_scope = mono_metadata_string_heap (image, scope_token);
|
||||
}
|
||||
piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
|
||||
import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
|
||||
scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
|
||||
orig_scope = mono_metadata_string_heap (image, scope_token);
|
||||
|
||||
mono_dllmap_lookup (image, orig_scope, import, &new_scope, &import);
|
||||
|
||||
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
|
||||
"DllImport attempting to load: '%s'.", new_scope);
|
||||
|
||||
if (exc_class) {
|
||||
*exc_class = NULL;
|
||||
*exc_arg = NULL;
|
||||
}
|
||||
|
||||
#ifndef PLATFORM_WIN32
|
||||
/*
|
||||
* If we are P/Invoking a library from System.Windows.Forms, load Wine
|
||||
@@ -725,21 +712,6 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef PLATFORM_WIN32
|
||||
/* Try the stdcall mangled name */
|
||||
if (!method->addr) {
|
||||
/* FIX: Compute this correctly */
|
||||
mangled_name = g_strdup_printf ("%s@%d", import, method->signature->param_count * sizeof (gpointer));
|
||||
g_module_symbol (gmodule, mangled_name, &method->addr);
|
||||
g_free (mangled_name);
|
||||
}
|
||||
if (!method->addr) {
|
||||
mangled_name = g_strdup_printf ("_%s@%d", import, method->signature->param_count * sizeof (gpointer));
|
||||
g_module_symbol (gmodule, mangled_name, &method->addr);
|
||||
g_free (mangled_name);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
if (!method->addr) {
|
||||
|
||||
+10
-12
@@ -25,7 +25,7 @@
|
||||
|
||||
#include <locale.h>
|
||||
|
||||
#undef DEBUG
|
||||
//#undef DEBUG
|
||||
|
||||
static gint32 string_invariant_compare_char (gunichar2 c1, gunichar2 c2,
|
||||
gint32 options);
|
||||
@@ -1041,7 +1041,6 @@ void ves_icall_System_Globalization_CompareInfo_free_internal_collator (MonoComp
|
||||
|
||||
coll=this->ICU_collator;
|
||||
if(coll!=NULL) {
|
||||
this->ICU_collator = NULL;
|
||||
ucol_close (coll);
|
||||
}
|
||||
}
|
||||
@@ -1432,11 +1431,6 @@ MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this,
|
||||
* does match properly...
|
||||
*/
|
||||
match_len = usearch_getMatchedLength (search);
|
||||
|
||||
if(match_len == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
match=(UChar *)g_malloc0 (sizeof(UChar) * (match_len + 1));
|
||||
usearch_getMatchedText (search, match, match_len, &ec);
|
||||
|
||||
@@ -1473,11 +1467,6 @@ MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this,
|
||||
pos!=USEARCH_DONE;
|
||||
pos=usearch_next (search, &ec)) {
|
||||
match_len = usearch_getMatchedLength (search);
|
||||
|
||||
if (match_len == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
match=(UChar *)g_malloc0 (sizeof(UChar) * (match_len + 1));
|
||||
usearch_getMatchedText (search, match, match_len, &ec);
|
||||
|
||||
@@ -1876,6 +1865,15 @@ static gint32 string_invariant_compare_char (gunichar2 c1, gunichar2 c2,
|
||||
/* No options. Kana, symbol and spacing options don't
|
||||
* apply to the invariant culture.
|
||||
*/
|
||||
if (c1type == G_UNICODE_UPPERCASE_LETTER &&
|
||||
c2type == G_UNICODE_LOWERCASE_LETTER) {
|
||||
return(1);
|
||||
}
|
||||
|
||||
if (c1type == G_UNICODE_LOWERCASE_LETTER &&
|
||||
c2type == G_UNICODE_UPPERCASE_LETTER) {
|
||||
return(-1);
|
||||
}
|
||||
|
||||
result = (gint32) c1 - c2;
|
||||
}
|
||||
|
||||
+71
-184
@@ -45,6 +45,9 @@ struct _MonoMethodBuilder {
|
||||
static void
|
||||
emit_struct_conv (MonoMethodBuilder *mb, MonoClass *klass, gboolean to_object);
|
||||
|
||||
static gint
|
||||
mono_marshal_runtime_glist_find_klass (gconstpointer a, gconstpointer b);
|
||||
|
||||
static MonoMethod *
|
||||
mono_find_method_by_name (MonoClass *klass, const char *name, int param_count)
|
||||
{
|
||||
@@ -221,20 +224,17 @@ mono_string_builder_to_utf8 (MonoStringBuilder *sb)
|
||||
{
|
||||
GError *error = NULL;
|
||||
glong *res;
|
||||
gchar *tmp;
|
||||
|
||||
if (!sb)
|
||||
return NULL;
|
||||
|
||||
res = g_malloc0 (mono_stringbuilder_capacity (sb) + 1);
|
||||
|
||||
tmp = g_utf16_to_utf8 (mono_string_chars (sb->str), sb->length, NULL, res, &error);
|
||||
g_utf16_to_utf8 (mono_string_chars (sb->str), sb->length, NULL, res, &error);
|
||||
if (error) {
|
||||
g_error_free (error);
|
||||
mono_raise_exception (mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8"));
|
||||
}
|
||||
else
|
||||
memcpy (res, tmp, sb->length + 1);
|
||||
|
||||
return res;
|
||||
}
|
||||
@@ -1270,52 +1270,6 @@ mono_marshal_get_string_encoding (MonoMethodPInvoke *piinfo, MonoMarshalSpec *sp
|
||||
}
|
||||
}
|
||||
|
||||
static MonoMarshalNative
|
||||
mono_marshal_get_stringbuilder_to_ptr_encoding (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
|
||||
{
|
||||
MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
|
||||
|
||||
switch (encoding) {
|
||||
case MONO_NATIVE_LPWSTR:
|
||||
return MONO_MARSHAL_CONV_SB_LPWSTR;
|
||||
break;
|
||||
case MONO_NATIVE_LPSTR:
|
||||
return MONO_MARSHAL_CONV_SB_LPSTR;
|
||||
break;
|
||||
case MONO_NATIVE_LPTSTR:
|
||||
return MONO_MARSHAL_CONV_SB_LPTSTR;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static MonoMarshalNative
|
||||
mono_marshal_get_ptr_to_stringbuilder_encoding (MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec, gboolean *need_free)
|
||||
{
|
||||
MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
|
||||
|
||||
*need_free = TRUE;
|
||||
|
||||
switch (encoding) {
|
||||
case MONO_NATIVE_LPWSTR:
|
||||
/*
|
||||
* mono_string_builder_to_utf16 does not allocate a
|
||||
* new buffer, so no need to free it.
|
||||
*/
|
||||
*need_free = FALSE;
|
||||
return MONO_MARSHAL_CONV_LPWSTR_SB;
|
||||
case MONO_NATIVE_LPSTR:
|
||||
return MONO_MARSHAL_CONV_LPSTR_SB;
|
||||
break;
|
||||
case MONO_NATIVE_LPTSTR:
|
||||
return MONO_MARSHAL_CONV_LPTSTR_SB;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static inline MonoMethod*
|
||||
mono_marshal_find_in_cache (GHashTable *cache, gpointer key)
|
||||
{
|
||||
@@ -1665,7 +1619,7 @@ mono_remoting_wrapper (MonoMethod *method, gpointer *params)
|
||||
}
|
||||
}
|
||||
|
||||
return mono_runtime_invoke (method, method->klass->valuetype? mono_object_unbox ((MonoObject*)this): this, mparams, NULL);
|
||||
return mono_runtime_invoke (method, method->klass->valuetype? mono_object_unbox (this): this, mparams, NULL);
|
||||
}
|
||||
|
||||
msg = mono_method_call_message_new (method, params, NULL, NULL, NULL);
|
||||
@@ -2198,19 +2152,6 @@ handle_enum:
|
||||
return res;
|
||||
}
|
||||
|
||||
static void
|
||||
raise_auto_layout_exception (MonoClass *klass)
|
||||
{
|
||||
char *msg = g_strdup_printf ("The type `%s.%s' layout needs to be Sequential or Explicit",
|
||||
klass->name_space, klass->name, NULL);
|
||||
|
||||
MonoException *e = mono_exception_from_name_msg (
|
||||
mono_get_corlib (), "System.Runtime.InteropServices",
|
||||
"MarshalDirectiveException", msg);
|
||||
g_free (msg);
|
||||
mono_raise_exception (e);
|
||||
}
|
||||
|
||||
/*
|
||||
* generates IL code to call managed methods from unmanaged code
|
||||
*/
|
||||
@@ -2372,9 +2313,8 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
|
||||
break;
|
||||
}
|
||||
|
||||
/* The class can not have an automatic layout */
|
||||
if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
|
||||
raise_auto_layout_exception (klass);
|
||||
/* FIXME: Raise a MarshalDirectiveException here */
|
||||
g_assert ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT);
|
||||
|
||||
if (t->attrs & PARAM_ATTRIBUTE_OUT) {
|
||||
mono_mb_emit_byte (mb, CEE_LDNULL);
|
||||
@@ -2636,17 +2576,8 @@ mono_marshal_get_managed_wrapper (MonoMethod *method, MonoObject *this, MonoMars
|
||||
|
||||
klass = sig->ret->data.klass;
|
||||
|
||||
if (klass->delegate) {
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_DEL_FTN);
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_3);
|
||||
break;
|
||||
}
|
||||
|
||||
/* The class can not have an automatic layout */
|
||||
if ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) == TYPE_ATTRIBUTE_AUTO_LAYOUT)
|
||||
raise_auto_layout_exception (klass);
|
||||
/* FIXME: Raise a MarshalDirectiveException here */
|
||||
g_assert ((klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT);
|
||||
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_0);
|
||||
/* Check for null */
|
||||
@@ -3453,22 +3384,31 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_DEL_FTN);
|
||||
mono_mb_emit_stloc (mb, tmp_locals [i]);
|
||||
} else if (klass == mono_defaults.stringbuilder_class) {
|
||||
MonoMarshalNative encoding = mono_marshal_get_stringbuilder_to_ptr_encoding (piinfo, spec);
|
||||
MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
|
||||
|
||||
g_assert (!t->byref);
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
|
||||
|
||||
if (encoding != -1)
|
||||
mono_mb_emit_byte (mb, encoding);
|
||||
else {
|
||||
switch (encoding) {
|
||||
case MONO_NATIVE_LPWSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_SB_LPWSTR);
|
||||
break;
|
||||
case MONO_NATIVE_LPSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_SB_LPSTR);
|
||||
break;
|
||||
case MONO_NATIVE_LPTSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_SB_LPTSTR);
|
||||
break;
|
||||
default: {
|
||||
char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
|
||||
MonoException *exc = mono_get_exception_not_implemented (msg);
|
||||
g_warning (msg);
|
||||
g_free (msg);
|
||||
mono_raise_exception (exc);
|
||||
}
|
||||
}
|
||||
|
||||
mono_mb_emit_stloc (mb, tmp_locals [i]);
|
||||
} else {
|
||||
@@ -3564,13 +3504,10 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
else {
|
||||
MonoClass *eklass;
|
||||
guint32 label1, label2, label3;
|
||||
int index_var, dest_ptr, esize;
|
||||
MonoMarshalNative encoding = mono_marshal_get_stringbuilder_to_ptr_encoding (piinfo, spec);
|
||||
int index_var, dest_ptr;
|
||||
|
||||
dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
|
||||
|
||||
eklass = klass->element_class;
|
||||
|
||||
/* Check null */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_stloc (mb, tmp_locals [i]);
|
||||
@@ -3579,23 +3516,9 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
label1 = mb->pos;
|
||||
mono_mb_emit_i4 (mb, 0);
|
||||
|
||||
if (eklass == mono_defaults.stringbuilder_class) {
|
||||
if (encoding == -1) {
|
||||
char *msg = g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
|
||||
MonoException *exc = mono_get_exception_not_implemented (msg);
|
||||
g_warning (msg);
|
||||
g_free (msg);
|
||||
mono_raise_exception (exc);
|
||||
}
|
||||
}
|
||||
|
||||
if (eklass == mono_defaults.stringbuilder_class)
|
||||
esize = sizeof (gpointer);
|
||||
else
|
||||
esize = mono_class_native_size (eklass, NULL);
|
||||
|
||||
/* allocate space for the native struct and store the address */
|
||||
mono_mb_emit_icon (mb, esize);
|
||||
eklass = klass->element_class;
|
||||
mono_mb_emit_icon (mb, mono_class_native_size (eklass, NULL));
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_byte (mb, CEE_LDLEN);
|
||||
mono_mb_emit_byte (mb, CEE_MUL);
|
||||
@@ -3620,34 +3543,22 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
|
||||
/* Emit marshalling code */
|
||||
|
||||
if (eklass == mono_defaults.stringbuilder_class) {
|
||||
mono_mb_emit_ldloc (mb, dest_ptr);
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEM_REF);
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_FUNC1);
|
||||
mono_mb_emit_byte (mb, encoding);
|
||||
mono_mb_emit_byte (mb, CEE_STIND_I);
|
||||
}
|
||||
else {
|
||||
/* set the src_ptr */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEMA);
|
||||
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_0);
|
||||
/* set the src_ptr */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEMA);
|
||||
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_0);
|
||||
|
||||
/* set dst_ptr */
|
||||
mono_mb_emit_ldloc (mb, dest_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_1);
|
||||
/* set dst_ptr */
|
||||
mono_mb_emit_ldloc (mb, dest_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_1);
|
||||
|
||||
/* emit valuetype conversion code */
|
||||
emit_struct_conv (mb, eklass, FALSE);
|
||||
}
|
||||
/* emit valuetype conversion code */
|
||||
emit_struct_conv (mb, eklass, FALSE);
|
||||
|
||||
mono_mb_emit_add_to_local (mb, index_var, 1);
|
||||
mono_mb_emit_add_to_local (mb, dest_ptr, esize);
|
||||
mono_mb_emit_add_to_local (mb, dest_ptr, mono_class_native_size (eklass, NULL));
|
||||
|
||||
mono_mb_emit_byte (mb, CEE_BR);
|
||||
mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
|
||||
@@ -4074,20 +3985,33 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
case MONO_TYPE_CLASS:
|
||||
case MONO_TYPE_OBJECT:
|
||||
if (t->data.klass == mono_defaults.stringbuilder_class) {
|
||||
gboolean need_free;
|
||||
MonoMarshalNative encoding;
|
||||
|
||||
encoding = mono_marshal_get_ptr_to_stringbuilder_encoding (piinfo, spec, &need_free);
|
||||
MonoMarshalNative encoding = mono_marshal_get_string_encoding (piinfo, spec);
|
||||
gboolean need_free = TRUE;
|
||||
|
||||
g_assert (!t->byref);
|
||||
g_assert (encoding != -1);
|
||||
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, tmp_locals [i]);
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_PROC2);
|
||||
|
||||
mono_mb_emit_byte (mb, encoding);
|
||||
switch (encoding) {
|
||||
case MONO_NATIVE_LPWSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPWSTR_SB);
|
||||
/*
|
||||
* mono_string_builder_to_utf16 does not allocate a
|
||||
* new buffer, so no need to free it.
|
||||
*/
|
||||
need_free = FALSE;
|
||||
break;
|
||||
case MONO_NATIVE_LPSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPSTR_SB);
|
||||
break;
|
||||
case MONO_NATIVE_LPTSTR:
|
||||
mono_mb_emit_byte (mb, MONO_MARSHAL_CONV_LPTSTR_SB);
|
||||
break;
|
||||
default:
|
||||
g_assert_not_reached ();
|
||||
}
|
||||
|
||||
if (need_free) {
|
||||
mono_mb_emit_ldloc (mb, tmp_locals [i]);
|
||||
@@ -4202,17 +4126,13 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
}
|
||||
|
||||
/* Character arrays are implicitly marshalled as [Out] */
|
||||
if ((klass->element_class == mono_defaults.char_class) || (klass->element_class == mono_defaults.stringbuilder_class) || (t->attrs & PARAM_ATTRIBUTE_OUT)) {
|
||||
if ((klass->element_class == mono_defaults.char_class) || (t->attrs & PARAM_ATTRIBUTE_OUT)) {
|
||||
/* FIXME: Optimize blittable case */
|
||||
MonoClass *eklass;
|
||||
guint32 label1, label2, label3;
|
||||
int index_var, src_ptr, esize;
|
||||
int index_var, src_ptr;
|
||||
|
||||
eklass = klass->element_class;
|
||||
if (eklass == mono_defaults.stringbuilder_class)
|
||||
esize = sizeof (gpointer);
|
||||
else
|
||||
esize = mono_class_native_size (eklass, NULL);
|
||||
src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
|
||||
|
||||
/* Check null */
|
||||
@@ -4238,53 +4158,22 @@ mono_marshal_get_native_wrapper (MonoMethod *method)
|
||||
|
||||
/* Emit marshalling code */
|
||||
|
||||
if (eklass == mono_defaults.stringbuilder_class) {
|
||||
gboolean need_free;
|
||||
MonoMarshalNative encoding = mono_marshal_get_ptr_to_stringbuilder_encoding (piinfo, spec, &need_free);
|
||||
/* set the src_ptr */
|
||||
mono_mb_emit_ldloc (mb, src_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_0);
|
||||
|
||||
g_assert (encoding != -1);
|
||||
/* set dst_ptr */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEMA);
|
||||
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_1);
|
||||
|
||||
/* dest */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEM_REF);
|
||||
|
||||
/* src */
|
||||
mono_mb_emit_ldloc (mb, src_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_LDIND_I);
|
||||
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_PROC2);
|
||||
|
||||
mono_mb_emit_byte (mb, encoding);
|
||||
|
||||
if (need_free) {
|
||||
/* src */
|
||||
mono_mb_emit_ldloc (mb, src_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_LDIND_I);
|
||||
|
||||
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
|
||||
mono_mb_emit_byte (mb, CEE_MONO_FREE);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* set the src_ptr */
|
||||
mono_mb_emit_ldloc (mb, src_ptr);
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_0);
|
||||
|
||||
/* set dst_ptr */
|
||||
mono_mb_emit_ldarg (mb, argnum);
|
||||
mono_mb_emit_ldloc (mb, index_var);
|
||||
mono_mb_emit_byte (mb, CEE_LDELEMA);
|
||||
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, eklass));
|
||||
mono_mb_emit_byte (mb, CEE_STLOC_1);
|
||||
|
||||
/* emit valuetype conversion code */
|
||||
emit_struct_conv (mb, eklass, TRUE);
|
||||
}
|
||||
/* emit valuetype conversion code */
|
||||
emit_struct_conv (mb, eklass, TRUE);
|
||||
|
||||
mono_mb_emit_add_to_local (mb, index_var, 1);
|
||||
mono_mb_emit_add_to_local (mb, src_ptr, esize);
|
||||
mono_mb_emit_add_to_local (mb, src_ptr, mono_class_native_size (eklass, NULL));
|
||||
|
||||
mono_mb_emit_byte (mb, CEE_BR);
|
||||
mono_mb_emit_i4 (mb, label2 - (mb->pos + 4));
|
||||
@@ -4860,8 +4749,6 @@ mono_marshal_alloc (gpointer size)
|
||||
{
|
||||
MONO_ARCH_SAVE_REGS;
|
||||
|
||||
if (size == NULL)
|
||||
size = (gpointer)4;
|
||||
return g_try_malloc ((gulong)size);
|
||||
}
|
||||
|
||||
|
||||
+51
-55
@@ -1203,10 +1203,6 @@ mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs,
|
||||
{
|
||||
MonoType *type, *cached;
|
||||
gboolean byref = FALSE;
|
||||
gboolean pinned = FALSE;
|
||||
const char *tmp_ptr;
|
||||
int count = 0;
|
||||
gboolean found;
|
||||
|
||||
/*
|
||||
* According to the spec, custom modifiers should come before the byref
|
||||
@@ -1216,70 +1212,70 @@ mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs,
|
||||
* Also, this type seems to be different from 'object & modopt(...)'. Maybe
|
||||
* it would be better to treat byref as real type constructor instead of
|
||||
* a modifier...
|
||||
* Also, pinned should come before anything else, but some MSV++ produced
|
||||
* assemblies violate this (#bug 61990).
|
||||
*/
|
||||
|
||||
/* Count the modifiers first */
|
||||
tmp_ptr = ptr;
|
||||
found = TRUE;
|
||||
while (found) {
|
||||
switch (*tmp_ptr) {
|
||||
case MONO_TYPE_PINNED:
|
||||
case MONO_TYPE_BYREF:
|
||||
++tmp_ptr;
|
||||
break;
|
||||
case MONO_TYPE_CMOD_REQD:
|
||||
case MONO_TYPE_CMOD_OPT:
|
||||
count ++;
|
||||
mono_metadata_parse_custom_mod (m, NULL, tmp_ptr, &tmp_ptr);
|
||||
break;
|
||||
default:
|
||||
found = FALSE;
|
||||
}
|
||||
if (*ptr == MONO_TYPE_BYREF) {
|
||||
byref = TRUE;
|
||||
++ptr;
|
||||
}
|
||||
|
||||
if (count) {
|
||||
type = g_malloc0 (sizeof (MonoType) + ((gint32)count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod));
|
||||
type->num_mods = count;
|
||||
if (count > 64)
|
||||
g_warning ("got more than 64 modifiers in type");
|
||||
switch (mode) {
|
||||
case MONO_PARSE_MOD_TYPE:
|
||||
case MONO_PARSE_PARAM:
|
||||
case MONO_PARSE_RET:
|
||||
case MONO_PARSE_LOCAL: /* should not have modifiers according to the spec, but ms tools disagree */
|
||||
case MONO_PARSE_FIELD: {
|
||||
/* count the modifiers */
|
||||
const char *tmp_ptr = ptr;
|
||||
int count = 0;
|
||||
while (mono_metadata_parse_custom_mod (m, NULL, tmp_ptr, &tmp_ptr))
|
||||
count++;
|
||||
if (count) {
|
||||
type = g_malloc0 (sizeof (MonoType) + ((gint32)count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod));
|
||||
type->num_mods = count;
|
||||
if (count > 64)
|
||||
g_warning ("got more than 64 modifiers in type");
|
||||
/* save them this time */
|
||||
count = 0;
|
||||
while (mono_metadata_parse_custom_mod (m, &(type->modifiers [count]), ptr, &ptr))
|
||||
count++;
|
||||
break;
|
||||
} /* fall through */
|
||||
}
|
||||
else
|
||||
case MONO_PARSE_TYPE:
|
||||
/*
|
||||
* Later we can avoid doing this allocation.
|
||||
*/
|
||||
type = g_new0 (MonoType, 1);
|
||||
|
||||
/* Parse pinned, byref and custom modifiers */
|
||||
found = TRUE;
|
||||
count = 0;
|
||||
while (found) {
|
||||
switch (*ptr) {
|
||||
case MONO_TYPE_PINNED:
|
||||
pinned = TRUE;
|
||||
++ptr;
|
||||
break;
|
||||
case MONO_TYPE_BYREF:
|
||||
byref = TRUE;
|
||||
++ptr;
|
||||
break;
|
||||
case MONO_TYPE_CMOD_REQD:
|
||||
case MONO_TYPE_CMOD_OPT:
|
||||
count ++;
|
||||
mono_metadata_parse_custom_mod (m, &(type->modifiers [count]), ptr, &ptr);
|
||||
break;
|
||||
default:
|
||||
found = FALSE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
g_assert_not_reached ();
|
||||
}
|
||||
|
||||
type->attrs = opt_attrs;
|
||||
type->byref = byref;
|
||||
type->pinned = pinned ? 1 : 0;
|
||||
|
||||
do_mono_metadata_parse_type (type, m, ptr, &ptr);
|
||||
if (mode == MONO_PARSE_LOCAL) {
|
||||
/*
|
||||
* check for pinned flag
|
||||
*/
|
||||
if (*ptr == MONO_TYPE_PINNED) {
|
||||
type->pinned = 1;
|
||||
++ptr;
|
||||
}
|
||||
}
|
||||
|
||||
switch (*ptr) {
|
||||
case MONO_TYPE_BYREF:
|
||||
if (mode == MONO_PARSE_FIELD)
|
||||
g_warning ("A field type cannot be byref");
|
||||
type->byref = 1;
|
||||
ptr++;
|
||||
/* follow through */
|
||||
default:
|
||||
/*if (*ptr == MONO_TYPE_VOID && mode != MONO_PARSE_RET)
|
||||
g_error ("void not allowed in param");*/
|
||||
do_mono_metadata_parse_type (type, m, ptr, &ptr);
|
||||
break;
|
||||
}
|
||||
if (rptr)
|
||||
*rptr = ptr;
|
||||
|
||||
|
||||
+17
-49
@@ -45,6 +45,8 @@ extern void (*mono_debugger_class_init_func) (MonoClass *klass);
|
||||
void
|
||||
mono_debug_init (MonoDomain *domain, MonoDebugFormat format)
|
||||
{
|
||||
MonoAssembly **ass;
|
||||
|
||||
g_assert (!mono_debug_initialized);
|
||||
|
||||
mono_debug_initialized = TRUE;
|
||||
@@ -344,35 +346,25 @@ gchar *
|
||||
mono_debug_source_location_from_address (MonoMethod *method, guint32 address, guint32 *line_number,
|
||||
MonoDomain *domain)
|
||||
{
|
||||
char *res;
|
||||
MonoDebugMethodInfo *minfo;
|
||||
MonoDebugMethodInfo *minfo = _mono_debug_lookup_method (method);
|
||||
MonoDebugDomainData *domain_data;
|
||||
|
||||
mono_loader_lock ();
|
||||
minfo = _mono_debug_lookup_method (method);
|
||||
if (!minfo || !minfo->handle || !minfo->handle->symfile ||
|
||||
!minfo->handle->symfile->offset_table) {
|
||||
mono_loader_unlock ();
|
||||
if (!minfo)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
domain_data = mono_debug_get_domain_data (minfo->handle, domain);
|
||||
if (!domain_data->jit [minfo->index]) {
|
||||
mono_loader_unlock ();
|
||||
if (!domain_data->jit [minfo->index])
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (minfo->handle && minfo->handle->symfile) {
|
||||
if (minfo->handle) {
|
||||
gint32 offset = il_offset_from_address (domain_data->jit [minfo->index], address);
|
||||
char *res = NULL;
|
||||
|
||||
if (offset >= 0)
|
||||
res = mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
|
||||
mono_loader_unlock ();
|
||||
return res;
|
||||
if (offset < 0)
|
||||
return NULL;
|
||||
|
||||
return mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
|
||||
}
|
||||
|
||||
mono_loader_unlock ();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -389,19 +381,12 @@ mono_debug_source_location_from_address (MonoMethod *method, guint32 address, gu
|
||||
gchar *
|
||||
mono_debug_source_location_from_il_offset (MonoMethod *method, guint32 offset, guint32 *line_number)
|
||||
{
|
||||
char *res;
|
||||
MonoDebugMethodInfo *minfo;
|
||||
MonoDebugMethodInfo *minfo = _mono_debug_lookup_method (method);
|
||||
|
||||
mono_loader_lock ();
|
||||
minfo = _mono_debug_lookup_method (method);
|
||||
if (!minfo || !minfo->handle || !minfo->handle->symfile) {
|
||||
mono_loader_unlock ();
|
||||
if (!minfo || !minfo->handle)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
res = mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
|
||||
mono_loader_unlock ();
|
||||
return res;
|
||||
return mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -413,24 +398,17 @@ mono_debug_il_offset_from_address (MonoMethod *method, gint32 address, MonoDomai
|
||||
{
|
||||
MonoDebugMethodInfo *minfo;
|
||||
MonoDebugDomainData *domain_data;
|
||||
gint32 res;
|
||||
|
||||
if (address < 0)
|
||||
return -1;
|
||||
|
||||
mono_loader_lock ();
|
||||
minfo = _mono_debug_lookup_method (method);
|
||||
if (!minfo || !minfo->il_offsets || !minfo->handle || !minfo->handle->symfile ||
|
||||
!minfo->handle->symfile->offset_table) {
|
||||
mono_loader_unlock ();
|
||||
if (!minfo || !minfo->il_offsets)
|
||||
return -1;
|
||||
}
|
||||
|
||||
domain_data = mono_debug_get_domain_data (minfo->handle, domain);
|
||||
|
||||
res = il_offset_from_address (domain_data->jit [minfo->index], address);
|
||||
mono_loader_unlock ();
|
||||
return res;
|
||||
return il_offset_from_address (domain_data->jit [minfo->index], address);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -442,24 +420,17 @@ mono_debug_address_from_il_offset (MonoMethod *method, gint32 il_offset, MonoDom
|
||||
{
|
||||
MonoDebugMethodInfo *minfo;
|
||||
MonoDebugDomainData *domain_data;
|
||||
gint32 res;
|
||||
|
||||
if (il_offset < 0)
|
||||
return -1;
|
||||
|
||||
mono_loader_lock ();
|
||||
minfo = _mono_debug_lookup_method (method);
|
||||
if (!minfo || !minfo->il_offsets || !minfo->handle || !minfo->handle->symfile ||
|
||||
!minfo->handle->symfile->offset_table) {
|
||||
mono_loader_unlock ();
|
||||
if (!minfo || !minfo->il_offsets)
|
||||
return -1;
|
||||
}
|
||||
|
||||
domain_data = mono_debug_get_domain_data (minfo->handle, domain);
|
||||
|
||||
res = _mono_debug_address_from_il_offset (domain_data->jit [minfo->index], il_offset);
|
||||
mono_loader_unlock ();
|
||||
return res;
|
||||
return _mono_debug_address_from_il_offset (domain_data->jit [minfo->index], il_offset);
|
||||
}
|
||||
|
||||
MonoDebugDomainData *
|
||||
@@ -468,9 +439,6 @@ mono_debug_get_domain_data (MonoDebugHandle *handle, MonoDomain *domain)
|
||||
MonoDebugDomainData *data;
|
||||
int domain_id = mono_domain_get_id (domain);
|
||||
|
||||
/* We checked this earlier. */
|
||||
g_assert (handle->symfile);
|
||||
|
||||
for (data = handle->_priv->domain_table; data; data = data->_priv->next)
|
||||
if (data->domain_id == domain_id)
|
||||
return data;
|
||||
|
||||
+14
-25
@@ -90,7 +90,6 @@ typedef struct
|
||||
{
|
||||
guint32 initializing_tid;
|
||||
guint32 waiting_count;
|
||||
gboolean done;
|
||||
CRITICAL_SECTION initialization_section;
|
||||
} TypeInitializationLock;
|
||||
|
||||
@@ -178,38 +177,28 @@ mono_runtime_class_init (MonoVTable *vtable)
|
||||
InitializeCriticalSection (&lock->initialization_section);
|
||||
lock->initializing_tid = tid;
|
||||
lock->waiting_count = 1;
|
||||
lock->done = FALSE;
|
||||
/* grab the vtable lock while this thread still owns type_initialization_section */
|
||||
EnterCriticalSection (&lock->initialization_section);
|
||||
g_hash_table_insert (type_initialization_hash, vtable, lock);
|
||||
do_initialization = 1;
|
||||
} else {
|
||||
gpointer blocked;
|
||||
TypeInitializationLock *pending_lock;
|
||||
|
||||
if (lock->initializing_tid == tid || lock->done) {
|
||||
if (lock->initializing_tid == tid) {
|
||||
LeaveCriticalSection (&type_initialization_section);
|
||||
return;
|
||||
}
|
||||
/* see if the thread doing the initialization is already blocked on this thread */
|
||||
blocked = GUINT_TO_POINTER (lock->initializing_tid);
|
||||
while ((pending_lock = (TypeInitializationLock*) g_hash_table_lookup (blocked_thread_hash, blocked))) {
|
||||
if (pending_lock->initializing_tid == tid) {
|
||||
if (!pending_lock->done) {
|
||||
LeaveCriticalSection (&type_initialization_section);
|
||||
return;
|
||||
} else {
|
||||
/* the thread doing the initialization is blocked on this thread,
|
||||
but on a lock that has already been freed. It just hasn't got
|
||||
time to awake */
|
||||
break;
|
||||
}
|
||||
while ((blocked = g_hash_table_lookup (blocked_thread_hash, blocked))) {
|
||||
if (blocked == GUINT_TO_POINTER (tid)) {
|
||||
LeaveCriticalSection (&type_initialization_section);
|
||||
return;
|
||||
}
|
||||
blocked = GUINT_TO_POINTER (pending_lock->initializing_tid);
|
||||
}
|
||||
++lock->waiting_count;
|
||||
/* record the fact that we are waiting on the initializing thread */
|
||||
g_hash_table_insert (blocked_thread_hash, GUINT_TO_POINTER (tid), lock);
|
||||
g_hash_table_insert (blocked_thread_hash, GUINT_TO_POINTER (tid), GUINT_TO_POINTER (lock->initializing_tid));
|
||||
}
|
||||
LeaveCriticalSection (&type_initialization_section);
|
||||
|
||||
@@ -217,7 +206,6 @@ mono_runtime_class_init (MonoVTable *vtable)
|
||||
mono_runtime_invoke (method, NULL, NULL, (MonoObject **) &exc);
|
||||
if (last_domain)
|
||||
mono_domain_set (last_domain, TRUE);
|
||||
lock->done = TRUE;
|
||||
LeaveCriticalSection (&lock->initialization_section);
|
||||
} else {
|
||||
/* this just blocks until the initializing thread is done */
|
||||
@@ -1598,9 +1586,13 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
|
||||
case MONO_TYPE_R4:
|
||||
case MONO_TYPE_R8:
|
||||
case MONO_TYPE_VALUETYPE:
|
||||
/* MS seems to create the objects if a null is passed in */
|
||||
if (! ((gpointer *)params->vector)[i])
|
||||
((gpointer*)params->vector)[i] = mono_object_new (mono_domain_get (), mono_class_from_mono_type (sig->params [i]));
|
||||
if (sig->params [i]->byref) {
|
||||
/* MS seems to create the objects if a null is passed in */
|
||||
if (! ((gpointer *)params->vector)[i])
|
||||
((gpointer*)params->vector)[i] = mono_object_new (mono_domain_get (), mono_class_from_mono_type (sig->params [i]));
|
||||
}
|
||||
else
|
||||
g_assert (((gpointer*)params->vector) [i]);
|
||||
pa [i] = (char *)(((gpointer *)params->vector)[i]) + sizeof (MonoObject);
|
||||
break;
|
||||
case MONO_TYPE_STRING:
|
||||
@@ -2723,7 +2715,6 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
|
||||
MonoDomain *domain;
|
||||
MonoMethod *method;
|
||||
MonoMethodSignature *sig;
|
||||
MonoObject *ret;
|
||||
int i, j, outarg_count = 0;
|
||||
|
||||
if (target && target->vtable->klass == mono_defaults.transparent_proxy_class) {
|
||||
@@ -2748,8 +2739,6 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
|
||||
*out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
|
||||
*exc = NULL;
|
||||
|
||||
ret = mono_runtime_invoke_array (method, method->klass->valuetype? mono_object_unbox (target): target, msg->args, exc);
|
||||
|
||||
for (i = 0, j = 0; i < sig->param_count; i++) {
|
||||
if (sig->params [i]->byref) {
|
||||
gpointer arg;
|
||||
@@ -2759,7 +2748,7 @@ mono_message_invoke (MonoObject *target, MonoMethodMessage *msg,
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
return mono_runtime_invoke_array (method, method->klass->valuetype? mono_object_unbox (target): target, msg->args, exc);
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
@@ -252,11 +252,5 @@ mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObjec
|
||||
MonoObject*
|
||||
mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc);
|
||||
|
||||
/* GC handles support */
|
||||
guint32 mono_gchandle_new (MonoObject *obj, gboolean pinned);
|
||||
guint32 mono_gchandle_new_weakref (MonoObject *obj, gboolean track_resurrection);
|
||||
MonoObject* mono_gchandle_get_target (guint32 gchandle);
|
||||
void mono_gchandle_free (guint32 gchandle);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -738,7 +738,7 @@ complete_path (const gunichar2 *appname, gunichar2 **completed)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (g_file_test (utf8app, G_FILE_TEST_IS_EXECUTABLE) && !g_file_test (utf8app, G_FILE_TEST_IS_DIR)) {
|
||||
if (g_file_test (utf8app, G_FILE_TEST_IS_EXECUTABLE)) {
|
||||
g_free (utf8app);
|
||||
return FALSE;
|
||||
}
|
||||
@@ -875,9 +875,7 @@ MonoBoolean ves_icall_System_Diagnostics_Process_Start_internal (MonoString *app
|
||||
|
||||
if(ret) {
|
||||
process_info->process_handle=procinfo.hProcess;
|
||||
/*process_info->thread_handle=procinfo.hThread;*/
|
||||
process_info->thread_handle=NULL;
|
||||
CloseHandle(procinfo.hThread);
|
||||
process_info->thread_handle=procinfo.hThread;
|
||||
process_info->pid=procinfo.dwProcessId;
|
||||
process_info->tid=procinfo.dwThreadId;
|
||||
} else {
|
||||
|
||||
@@ -61,9 +61,6 @@ typedef struct {
|
||||
MonoMethod *mhandle;
|
||||
guint32 nrefs;
|
||||
gpointer *refs;
|
||||
/* for PInvoke */
|
||||
int charset, lasterr, native_cc;
|
||||
MonoString *dll, *dllentry;
|
||||
} ReflectionMethodBuilder;
|
||||
|
||||
const unsigned char table_sizes [64] = {
|
||||
@@ -890,8 +887,6 @@ method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
|
||||
max_stack = 8; /* we probably need to run a verifier on the code... */
|
||||
}
|
||||
|
||||
stream_data_align (&assembly->code);
|
||||
|
||||
/* check for exceptions, maxstack, locals */
|
||||
maybe_small = (max_stack <= 8) && (!num_locals) && (!num_exception);
|
||||
if (maybe_small) {
|
||||
@@ -1265,14 +1260,6 @@ reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb,
|
||||
rmb->mhandle = mb->mhandle;
|
||||
rmb->nrefs = 0;
|
||||
rmb->refs = NULL;
|
||||
|
||||
if (mb->dll) {
|
||||
rmb->charset = rmb->charset & 0xf;
|
||||
rmb->lasterr = rmb->charset & 0x40;
|
||||
rmb->native_cc = rmb->native_cc;
|
||||
rmb->dllentry = mb->dllentry;
|
||||
rmb->dll = mb->dll;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -2729,8 +2716,7 @@ mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, Mon
|
||||
* if we have explicitlayout or sequentiallayouts, output data in the
|
||||
* ClassLayout table.
|
||||
*/
|
||||
if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) &&
|
||||
((tb->class_size > 0) || (tb->packing_size > 0))) {
|
||||
if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) && (tb->class_size != -1)) {
|
||||
table = &assembly->tables [MONO_TABLE_CLASSLAYOUT];
|
||||
table->rows++;
|
||||
alloc_table (table, table->rows);
|
||||
@@ -5270,21 +5256,12 @@ MonoArray*
|
||||
mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
|
||||
{
|
||||
static MonoClass *System_Reflection_ParameterInfo;
|
||||
static MonoClassField *dbnull_value_field;
|
||||
MonoClass *klass;
|
||||
MonoArray *res = NULL;
|
||||
MonoReflectionMethod *member = NULL;
|
||||
MonoReflectionParameter *param = NULL;
|
||||
char **names;
|
||||
int i;
|
||||
|
||||
if (!dbnull_value_field) {
|
||||
klass = mono_class_from_name (mono_defaults.corlib, "System", "DBNull");
|
||||
mono_class_init (klass);
|
||||
dbnull_value_field = mono_class_get_field_from_name (klass, "Value");
|
||||
g_assert (dbnull_value_field);
|
||||
}
|
||||
|
||||
if (!System_Reflection_ParameterInfo)
|
||||
System_Reflection_ParameterInfo = mono_class_from_name (
|
||||
mono_defaults.corlib, "System.Reflection", "ParameterInfo");
|
||||
@@ -5306,7 +5283,7 @@ mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
|
||||
param = (MonoReflectionParameter *)mono_object_new (domain,
|
||||
System_Reflection_ParameterInfo);
|
||||
param->ClassImpl = mono_type_get_object (domain, method->signature->params [i]);
|
||||
param->DefaultValueImpl = mono_field_get_value_object (domain, dbnull_value_field, NULL); /* FIXME */
|
||||
param->DefaultValueImpl = NULL; /* FIXME */
|
||||
param->MemberImpl = (MonoObject*)member;
|
||||
param->NameImpl = mono_string_new (domain, names [i]);
|
||||
param->PositionImpl = i;
|
||||
@@ -5891,7 +5868,6 @@ handle_type:
|
||||
}
|
||||
break;
|
||||
case MONO_TYPE_CLASS:
|
||||
case MONO_TYPE_OBJECT:
|
||||
case MONO_TYPE_STRING:
|
||||
for (i = 0; i < alen; i++) {
|
||||
MonoObject *item = load_cattr_value (image, &t->data.klass->byval_arg, p, &p);
|
||||
@@ -7029,17 +7005,6 @@ reflection_methodbuilder_to_mono_method (MonoClass *klass,
|
||||
} else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
|
||||
/* TODO */
|
||||
m->signature->pinvoke = 1;
|
||||
|
||||
method_aux = g_new0 (MonoReflectionMethodAux, 1);
|
||||
|
||||
method_aux->dllentry = g_strdup (mono_string_to_utf8 (rmb->dllentry));
|
||||
method_aux->dll = g_strdup (mono_string_to_utf8 (rmb->dll));
|
||||
|
||||
((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 1) | rmb->lasterr;
|
||||
|
||||
if (klass->image->dynamic)
|
||||
mono_g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
|
||||
|
||||
return m;
|
||||
} else if (!m->klass->dummy &&
|
||||
!(m->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
|
||||
@@ -7853,7 +7818,6 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
|
||||
{
|
||||
MonoClass *klass;
|
||||
MonoReflectionType* res;
|
||||
int i;
|
||||
|
||||
MONO_ARCH_SAVE_REGS;
|
||||
|
||||
@@ -7864,6 +7828,7 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
|
||||
/*
|
||||
* Fields to set in klass:
|
||||
* the various flags: delegate/unicode/contextbound etc.
|
||||
* nested_classes
|
||||
*/
|
||||
klass->flags = tb->attrs;
|
||||
|
||||
@@ -7875,13 +7840,6 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
|
||||
if (!klass->enumtype)
|
||||
ensure_runtime_vtable (klass);
|
||||
|
||||
if (tb->subtypes) {
|
||||
for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
|
||||
MonoReflectionTypeBuilder *subtb = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
|
||||
klass->nested_classes = g_list_prepend (klass->nested_classes, my_mono_class_from_mono_type (subtb->type.type));
|
||||
}
|
||||
}
|
||||
|
||||
/* fields and object layout */
|
||||
if (klass->parent) {
|
||||
if (!klass->parent->size_inited)
|
||||
|
||||
@@ -34,7 +34,6 @@ typedef struct {
|
||||
char **param_names;
|
||||
MonoMarshalSpec **param_marshall;
|
||||
MonoCustomAttrInfo **param_cattr;
|
||||
char *dllentry, *dll;
|
||||
} MonoReflectionMethodAux;
|
||||
|
||||
int mono_reflection_parse_type (char *name, MonoTypeNameParse *info);
|
||||
|
||||
@@ -330,11 +330,6 @@ static gint32 convert_sockopt_level_and_name(MonoSocketOptionLevel mono_level,
|
||||
case SocketOptionName_Type:
|
||||
*system_name = SO_TYPE;
|
||||
break;
|
||||
#ifdef SO_PEERCRED
|
||||
case SocketOptionName_PeerCred:
|
||||
*system_name = SO_PEERCRED;
|
||||
break;
|
||||
#endif
|
||||
case SocketOptionName_ExclusiveAddressUse:
|
||||
case SocketOptionName_UseLoopback:
|
||||
case SocketOptionName_MaxConnections:
|
||||
@@ -1160,15 +1155,7 @@ gint32 ves_icall_System_Net_Sockets_Socket_RecvFrom_internal(SOCKET sock, MonoAr
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* If we didn't get a socket size, then we're probably a
|
||||
* connected connection-oriented socket and the stack hasn't
|
||||
* returned the remote address. All we can do is return null.
|
||||
*/
|
||||
if ( sa_size != 0 )
|
||||
*sockaddr=create_object_from_sockaddr(sa, sa_size, error);
|
||||
else
|
||||
*sockaddr=NULL;
|
||||
|
||||
*sockaddr=create_object_from_sockaddr(sa, sa_size, error);
|
||||
g_free(sa);
|
||||
|
||||
return(ret);
|
||||
@@ -1441,10 +1428,6 @@ void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET soc
|
||||
int lingersize=sizeof(linger);
|
||||
struct timeval tv;
|
||||
int tvsize=sizeof(tv);
|
||||
#ifdef SO_PEERCRED
|
||||
struct ucred cred;
|
||||
int credsize = sizeof(cred);
|
||||
#endif
|
||||
MonoDomain *domain=mono_domain_get();
|
||||
MonoObject *obj;
|
||||
MonoClass *obj_class;
|
||||
@@ -1478,13 +1461,6 @@ void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET soc
|
||||
&tvsize);
|
||||
break;
|
||||
|
||||
#ifdef SO_PEERCRED
|
||||
case SocketOptionName_PeerCred:
|
||||
ret = _wapi_getsockopt (sock, system_level, system_name, &cred,
|
||||
&credsize);
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
ret = _wapi_getsockopt (sock, system_level, system_name, &val,
|
||||
&valsize);
|
||||
@@ -1524,32 +1500,6 @@ void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET soc
|
||||
obj = int_to_object (domain, (tv.tv_sec * 1000) + (tv.tv_usec / 1000));
|
||||
break;
|
||||
|
||||
#ifdef SO_PEERCRED
|
||||
case SocketOptionName_PeerCred:
|
||||
{
|
||||
/* build a Mono.Posix.PeerCred+PeerCredData if
|
||||
* possible
|
||||
*/
|
||||
MonoImage *mono_posix_image = mono_image_loaded ("Mono.Posix");
|
||||
MonoPeerCredData *cred_data;
|
||||
|
||||
if (mono_posix_image == NULL) {
|
||||
*error = WSAENOPROTOOPT;
|
||||
return;
|
||||
}
|
||||
|
||||
obj_class = mono_class_from_name(mono_posix_image,
|
||||
"Mono.Posix",
|
||||
"PeerCred/PeerCredData");
|
||||
obj = mono_object_new(domain, obj_class);
|
||||
cred_data = (MonoPeerCredData *)obj;
|
||||
cred_data->pid = cred.pid;
|
||||
cred_data->uid = cred.uid;
|
||||
cred_data->gid = cred.gid;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
default:
|
||||
obj = int_to_object (domain, val);
|
||||
}
|
||||
|
||||
@@ -130,12 +130,7 @@ typedef enum {
|
||||
SocketOptionName_BsdUrgent=2,
|
||||
SocketOptionName_Expedited=2,
|
||||
SocketOptionName_NoChecksum=1,
|
||||
SocketOptionName_ChecksumCoverage=20,
|
||||
|
||||
/* This is Mono-specific, keep it in sync with
|
||||
* Mono.Posix/PeerCred.cs
|
||||
*/
|
||||
SocketOptionName_PeerCred=10001
|
||||
SocketOptionName_ChecksumCoverage=20
|
||||
} MonoSocketOptionName;
|
||||
|
||||
typedef struct _MonoSocketAsyncResult {
|
||||
@@ -159,14 +154,6 @@ typedef struct _MonoSocketAsyncResult {
|
||||
gint error;
|
||||
} MonoSocketAsyncResult;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
MonoObject obj;
|
||||
gint pid;
|
||||
gint uid;
|
||||
gint gid;
|
||||
} MonoPeerCredData;
|
||||
|
||||
extern gpointer ves_icall_System_Net_Sockets_Socket_Socket_internal(MonoObject *this, gint32 family, gint32 type, gint32 proto, gint32 *error);
|
||||
extern void ves_icall_System_Net_Sockets_Socket_Close_internal(SOCKET sock, gint32 *error);
|
||||
extern gint32 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal(void);
|
||||
|
||||
+10
-35
@@ -31,7 +31,7 @@
|
||||
#include "threadpool.h"
|
||||
|
||||
/* maximum number of worker threads */
|
||||
int mono_max_worker_threads = 25; /* per available CPU? */
|
||||
int mono_max_worker_threads = 25; /* fixme: should be 25 per available CPU */
|
||||
static int mono_min_worker_threads = 0;
|
||||
|
||||
/* current number of worker threads */
|
||||
@@ -43,8 +43,6 @@ static int busy_worker_threads = 0;
|
||||
/* we use this to store a reference to the AsyncResult to avoid GC */
|
||||
static MonoGHashTable *ares_htable = NULL;
|
||||
|
||||
static CRITICAL_SECTION ares_lock;
|
||||
|
||||
/* we append a job */
|
||||
static HANDLE job_added;
|
||||
|
||||
@@ -93,12 +91,9 @@ mono_async_invoke (MonoAsyncResult *ares)
|
||||
}
|
||||
mono_monitor_exit ((MonoObject *) ares);
|
||||
|
||||
EnterCriticalSection (&ares_lock);
|
||||
mono_g_hash_table_remove (ares_htable, ares);
|
||||
LeaveCriticalSection (&ares_lock);
|
||||
}
|
||||
|
||||
|
||||
MonoAsyncResult *
|
||||
mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback,
|
||||
MonoObject *state)
|
||||
@@ -127,14 +122,11 @@ mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *
|
||||
ares->async_delegate = target;
|
||||
|
||||
if (!ares_htable) {
|
||||
InitializeCriticalSection (&ares_lock);
|
||||
ares_htable = mono_g_hash_table_new (NULL, NULL);
|
||||
job_added = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
|
||||
}
|
||||
|
||||
EnterCriticalSection (&ares_lock);
|
||||
mono_g_hash_table_insert (ares_htable, ares, ares);
|
||||
LeaveCriticalSection (&ares_lock);
|
||||
|
||||
busy = (int) InterlockedCompareExchange (&busy_worker_threads, 0, -1);
|
||||
worker = (int) InterlockedCompareExchange (&mono_worker_threads, 0, -1);
|
||||
@@ -211,19 +203,8 @@ mono_thread_pool_cleanup (void)
|
||||
static void
|
||||
append_job (MonoAsyncResult *ar)
|
||||
{
|
||||
GList *tmp;
|
||||
|
||||
EnterCriticalSection (&mono_delegate_section);
|
||||
if (async_call_queue == NULL) {
|
||||
async_call_queue = g_list_append (async_call_queue, ar);
|
||||
} else {
|
||||
for (tmp = async_call_queue; tmp && tmp->data != NULL; tmp = tmp->next);
|
||||
if (tmp == NULL) {
|
||||
async_call_queue = g_list_append (async_call_queue, ar);
|
||||
} else {
|
||||
tmp->data = ar;
|
||||
}
|
||||
}
|
||||
async_call_queue = g_list_append (async_call_queue, ar);
|
||||
LeaveCriticalSection (&mono_delegate_section);
|
||||
}
|
||||
|
||||
@@ -231,23 +212,17 @@ static MonoAsyncResult *
|
||||
dequeue_job (void)
|
||||
{
|
||||
MonoAsyncResult *ar = NULL;
|
||||
GList *tmp, *tmp2;
|
||||
GList *tmp = NULL;
|
||||
|
||||
EnterCriticalSection (&mono_delegate_section);
|
||||
tmp = async_call_queue;
|
||||
if (tmp) {
|
||||
ar = (MonoAsyncResult *) tmp->data;
|
||||
tmp->data = NULL;
|
||||
tmp2 = tmp;
|
||||
for (tmp2 = tmp; tmp2->next != NULL; tmp2 = tmp2->next);
|
||||
if (tmp2 != tmp) {
|
||||
async_call_queue = tmp->next;
|
||||
tmp->next = NULL;
|
||||
tmp2->next = tmp;
|
||||
tmp->prev = tmp2;
|
||||
}
|
||||
if (async_call_queue) {
|
||||
ar = (MonoAsyncResult *)async_call_queue->data;
|
||||
tmp = async_call_queue;
|
||||
async_call_queue = g_list_remove_link (tmp, tmp);
|
||||
}
|
||||
LeaveCriticalSection (&mono_delegate_section);
|
||||
if (tmp)
|
||||
g_list_free_1 (tmp);
|
||||
|
||||
return ar;
|
||||
}
|
||||
@@ -293,7 +268,7 @@ async_invoke_thread (gpointer data)
|
||||
}
|
||||
while (!data && timeout > 0);
|
||||
}
|
||||
|
||||
|
||||
if (!data) {
|
||||
workers = (int) InterlockedCompareExchange (&mono_worker_threads, 0, -1);
|
||||
min = (int) InterlockedCompareExchange (&mono_min_worker_threads, 0, -1);
|
||||
|
||||
@@ -243,9 +243,12 @@ static guint32 start_wrapper(void *data)
|
||||
mono_thread_push_appdomain_ref (mono_domain_get ());
|
||||
|
||||
thread_adjust_static_data (thread);
|
||||
#ifndef PLATFORM_WIN32
|
||||
#ifdef DEBUG
|
||||
g_message (G_GNUC_PRETTY_FUNCTION "start_wrapper for %d\n", thread->tid);
|
||||
#endif
|
||||
pthread_cleanup_push ((void (*) (void *)) mono_thread_detach, thread);
|
||||
#endif
|
||||
|
||||
start_func (this);
|
||||
#ifdef PLATFORM_WIN32
|
||||
@@ -270,6 +273,8 @@ static guint32 start_wrapper(void *data)
|
||||
TlsSetValue (current_object_key, NULL);
|
||||
|
||||
thread_cleanup (thread);
|
||||
#else
|
||||
pthread_cleanup_pop (1);
|
||||
#endif
|
||||
|
||||
return(0);
|
||||
|
||||
@@ -1,73 +1,4 @@
|
||||
2004-09-17 Zoltan Varga <[email protected]>
|
||||
|
||||
* mini.c (mono_method_to_ir): Fix LDSTR in dynamic methods. Fixes #66132.
|
||||
|
||||
2004-09-11 Ben Maurer <[email protected]>
|
||||
|
||||
* inssel.brg: make ldelema check aot friendly.
|
||||
|
||||
Thu Sep 9 20:57:53 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini-*.c, mini-ops.h, inssel-long32.brg: introduced
|
||||
OP_ADDCC_IMM and OP_SUBCC_IMM (add/sub immediate that will
|
||||
set the carry/borrow flag). The sparc and s390 implementations
|
||||
can now use optimized versions (and simplify the code). ppc bugfixes.
|
||||
|
||||
2004-09-02 Zoltan Varga <[email protected]>
|
||||
|
||||
* inssel-long32.brg: Fix OP_LCONV_TO_OVF_I1 rule. Fixes #64578.
|
||||
|
||||
2004-08-23 Zoltan Varga <[email protected]>
|
||||
|
||||
* inssel-x86.brg inssel-amd64: Add yet another missing tree->dreg assignment.
|
||||
|
||||
* mini-x86.c (mono_arch_local_regalloc): Fix bug in long register
|
||||
allocation. Fixes #63085.
|
||||
|
||||
2004-08-09 Zoltan Varga <[email protected]>
|
||||
|
||||
* inssel-x86.brg: Set dreg of LOCALLOC correctly.
|
||||
|
||||
Tue Aug 3 11:20:09 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini-ppc.c: mul.ovf.un exception name fix.
|
||||
|
||||
Tue Aug 3 11:19:07 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini-ppc.c: reg allocator fix.
|
||||
|
||||
Tue Aug 3 11:17:07 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini-ppc.c: make sure temp regs are not used for global reg
|
||||
allocation.
|
||||
|
||||
Tue Jul 27 16:05:19 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini-ppc.c, mini-sparc.c, mini-s390.c: keep track of line
|
||||
numbers in the debug info (spotted by Geoff Norton,
|
||||
<[email protected]>).
|
||||
|
||||
Mon Jul 12 17:47:00 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* inssel-ppc.brg: arguments on the stack are always
|
||||
relative to the stack pointer (spotted by Neale Ferguson).
|
||||
|
||||
2004-07-11 Gonzalo Paniagua Javier <[email protected]>
|
||||
|
||||
* exceptions-x86.c: delay appending the method name to the trace until
|
||||
after mono_jit_info_table_find is called, as this gets the real
|
||||
MonoMethod.
|
||||
|
||||
2004-07-08 Zoltan Varga <[email protected]>
|
||||
|
||||
* mini.c (handle_stack_args): Handle some corner cases. Fixes
|
||||
58863.
|
||||
|
||||
2004-07-05 Zoltan Varga <[email protected]>
|
||||
|
||||
* mini.c (optimize_branches): Fix linking of bblocks in branch->branch
|
||||
optimization.
|
||||
|
||||
Mon Jun 28 18:05:09 CEST 2004 Paolo Molaro <[email protected]>
|
||||
|
||||
* mini.c: reinstated mono_compile_get_interface_var()
|
||||
|
||||
@@ -263,12 +263,6 @@ class Tests {
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int test_4_addcc_imm () {
|
||||
long a = 3;
|
||||
long b = 0;
|
||||
return (int)(a - b + 1);
|
||||
}
|
||||
|
||||
static int test_5_sub () {
|
||||
long a = 8;
|
||||
long b = 3;
|
||||
|
||||
@@ -545,8 +545,6 @@ adc: dest:i src1:i src2:i len:4
|
||||
addcc: dest:i src1:i src2:i len:4
|
||||
subcc: dest:i src1:i src2:i len:4
|
||||
adc_imm: dest:i src1:i len:12
|
||||
addcc_imm: dest:i src1:i len:12
|
||||
subcc_imm: dest:i src1:i len:12
|
||||
sbb: dest:i src1:i src2:i len:4
|
||||
sbb_imm: dest:i src1:i len:12
|
||||
br_reg: src1:i len:8
|
||||
|
||||
@@ -354,9 +354,7 @@ loadr8_membase: dest:f src1:b len:6
|
||||
loadr8_spill_membase: src1:b len:8
|
||||
loadu4_mem: dest:i len:9
|
||||
move: dest:i src1:i len:2
|
||||
addcc_imm: dest:i src1:i len:6 clob:1
|
||||
add_imm: dest:i src1:i len:6 clob:1
|
||||
subcc_imm: dest:i src1:i len:6 clob:1
|
||||
sub_imm: dest:i src1:i len:6 clob:1
|
||||
mul_imm: dest:i src1:i len:6
|
||||
# there is no actual support for division or reminder by immediate
|
||||
|
||||
@@ -349,9 +349,7 @@ loadu4_mem: dest:i len:8
|
||||
move: dest:i src1:i len:4
|
||||
fmove: dest:f src1:f len:4
|
||||
add_imm: dest:i src1:i len:18
|
||||
addcc_imm: dest:i src1:i len:18
|
||||
sub_imm: dest:i src1:i len:18
|
||||
subcc_imm: dest:i src1:i len:18
|
||||
mul_imm: dest:i src1:i len:18
|
||||
# there is no actual support for division or reminder by immediate
|
||||
# we simulate them, though (but we need to change the burg rules
|
||||
|
||||
@@ -356,9 +356,7 @@ loadr8_membase: dest:f src1:b len:20
|
||||
loadu4_mem: dest:i len:8
|
||||
move: dest:i src1:i len:4
|
||||
add_imm: dest:i src1:i len:12
|
||||
addcc_imm: dest:i src1:i len:64
|
||||
sub_imm: dest:i src1:i len:12
|
||||
subcc_imm: dest:i src1:i len:64
|
||||
mul_imm: dest:i src1:i len:12
|
||||
div_imm: dest:a src1:i src2:i len:28
|
||||
div_un_imm: dest:a src1:i src2:i len:12
|
||||
|
||||
@@ -462,6 +462,9 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf
|
||||
if (!(*lmf)->method)
|
||||
return (gpointer)-1;
|
||||
|
||||
if (trace)
|
||||
*trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
|
||||
|
||||
if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
|
||||
*res = *ji;
|
||||
} else {
|
||||
@@ -469,9 +472,6 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf
|
||||
res->method = (*lmf)->method;
|
||||
}
|
||||
|
||||
if (trace)
|
||||
*trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name (res->method, TRUE));
|
||||
|
||||
new_ctx->SC_ESI = (*lmf)->esi;
|
||||
new_ctx->SC_EDI = (*lmf)->edi;
|
||||
new_ctx->SC_EBX = (*lmf)->ebx;
|
||||
|
||||
@@ -108,7 +108,7 @@ lreg: OP_LADD_OVF_UN (lreg, lreg) {
|
||||
}
|
||||
|
||||
lreg: OP_LADD (lreg, i8con) {
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_ADDCC_IMM, state->reg1, state->left->reg1, state->right->tree->inst_ls_word);
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->left->reg1, state->right->tree->inst_ls_word);
|
||||
MONO_EMIT_BIALU_IMM (s, tree, OP_ADC_IMM, state->reg2, state->left->reg2, state->right->tree->inst_ms_word);
|
||||
}
|
||||
|
||||
@@ -118,7 +118,7 @@ lreg: OP_LSUB (lreg, lreg) {
|
||||
}
|
||||
|
||||
lreg: OP_LSUB (lreg, i8con) {
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_SUBCC_IMM, state->reg1, state->left->reg1, state->right->tree->inst_ls_word);
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_SUB_IMM, state->reg1, state->left->reg1, state->right->tree->inst_ls_word);
|
||||
MONO_EMIT_BIALU_IMM (s, tree, OP_SBB_IMM, state->reg2, state->left->reg2, state->right->tree->inst_ms_word);
|
||||
}
|
||||
|
||||
@@ -575,30 +575,15 @@ reg: OP_LCONV_TO_OVF_I1_UN (lreg) {
|
||||
}
|
||||
|
||||
reg: OP_LCONV_TO_OVF_I1 (lreg) {
|
||||
MonoInst *is_negative, *end_label;
|
||||
|
||||
MONO_NEW_LABEL (s, is_negative);
|
||||
MONO_NEW_LABEL (s, end_label);
|
||||
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg2, 0);
|
||||
MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg2, -1);
|
||||
MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
|
||||
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg2, 0);
|
||||
MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BLT, is_negative);
|
||||
|
||||
/* Positive */
|
||||
MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 127);
|
||||
MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
|
||||
MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
|
||||
|
||||
/* Negative */
|
||||
mono_bblock_add_inst (s->cbb, is_negative);
|
||||
MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
|
||||
MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, -128);
|
||||
MONO_EMIT_NEW_COND_EXC (s, LT_UN, "OverflowException");
|
||||
mono_bblock_add_inst (s->cbb, end_label);
|
||||
|
||||
MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
|
||||
MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
|
||||
}
|
||||
|
||||
|
||||
+10
-10
@@ -131,7 +131,7 @@ stmt: OP_SETRET (OP_ICONST) {
|
||||
|
||||
stmt: OP_OUTARG (reg) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETREG;
|
||||
@@ -142,7 +142,7 @@ stmt: OP_OUTARG (reg) {
|
||||
|
||||
stmt: OP_OUTARG (OP_REGVAR) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->tree->dreg);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->tree->dreg);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETREG;
|
||||
@@ -153,8 +153,8 @@ stmt: OP_OUTARG (OP_REGVAR) {
|
||||
|
||||
stmt: OP_OUTARG (lreg) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg2);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm + 4, state->left->reg1);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg2);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm + 4, state->left->reg1);
|
||||
return;
|
||||
}
|
||||
MONO_EMIT_NEW_UNALU (s, OP_SETREG, tree->unused, state->left->reg2);
|
||||
@@ -166,7 +166,7 @@ stmt: OP_OUTARG (lreg) {
|
||||
|
||||
stmt: OP_OUTARG (OP_ICONST) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, tree->inst_imm, state->left->tree->inst_c0);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, s->frame_reg, tree->inst_imm, state->left->tree->inst_c0);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETREGIMM;
|
||||
@@ -205,7 +205,7 @@ stmt: OP_OUTARG (OP_ICONST) {
|
||||
|
||||
stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->left->tree->dreg);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->left->tree->dreg);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETREG;
|
||||
@@ -223,7 +223,7 @@ stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
|
||||
stmt: OP_OUTARG (freg) {
|
||||
if (tree->inst_imm) {
|
||||
int opcode = (tree->unused & 0xff00) == 0x0400? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, tree->inst_imm, state->left->reg1);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, s->frame_reg, tree->inst_imm, state->left->reg1);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETFREG;
|
||||
@@ -234,7 +234,7 @@ stmt: OP_OUTARG (freg) {
|
||||
|
||||
stmt: OP_OUTARG_R4 (freg) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETFREG;
|
||||
@@ -245,7 +245,7 @@ stmt: OP_OUTARG_R4 (freg) {
|
||||
|
||||
stmt: OP_OUTARG_R8 (freg) {
|
||||
if (tree->inst_imm) {
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
|
||||
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
|
||||
return;
|
||||
}
|
||||
tree->opcode = OP_SETFREG;
|
||||
@@ -269,7 +269,7 @@ stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
|
||||
}
|
||||
//g_print ("vt size: %d at R%d + %d\n", tree->inst_imm, vt->inst_basereg, vt->inst_offset);
|
||||
if (ovf_size != 0) {
|
||||
mini_emit_memcpy (s, ppc_r1, tree->inst_imm + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
|
||||
mini_emit_memcpy (s, s->frame_reg, tree->inst_imm + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -151,7 +151,6 @@ reg: OP_LOCALLOC (OP_ICONST) {
|
||||
if (tree->flags & MONO_INST_INIT) {
|
||||
/* microcoded in mini-x86.c */
|
||||
tree->sreg1 = mono_regstate_next_int (s->rs);
|
||||
tree->dreg = state->reg1;
|
||||
MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
|
||||
mono_bblock_add_inst (s->cbb, tree);
|
||||
} else {
|
||||
@@ -162,7 +161,6 @@ reg: OP_LOCALLOC (OP_ICONST) {
|
||||
|
||||
reg: OP_LOCALLOC (reg) {
|
||||
tree->sreg1 = state->left->tree->dreg;
|
||||
tree->dreg = state->reg1;
|
||||
mono_bblock_add_inst (s->cbb, tree);
|
||||
}
|
||||
|
||||
|
||||
@@ -1736,14 +1736,7 @@ reg: OP_CHECK_ARRAY_TYPE (reg) {
|
||||
vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
|
||||
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, elclass_reg,
|
||||
class_reg, G_STRUCT_OFFSET (MonoClass, element_class));
|
||||
if (mono_compile_aot) {
|
||||
int klass_reg = mono_regstate_next_int (s->rs);
|
||||
MONO_EMIT_NEW_CLASSCONST (s, klass_reg, tree->klass);
|
||||
MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, elclass_reg, klass_reg);
|
||||
} else {
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, elclass_reg, tree->klass);
|
||||
}
|
||||
|
||||
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, elclass_reg, tree->klass);
|
||||
MONO_EMIT_NEW_COND_EXC (s, NE_UN, "ArrayTypeMismatchException");
|
||||
MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
|
||||
}
|
||||
|
||||
@@ -297,9 +297,7 @@ MINI_OP(OP_ADC_IMM, "adc_imm")
|
||||
MINI_OP(OP_SBB, "sbb")
|
||||
MINI_OP(OP_SBB_IMM, "sbb_imm")
|
||||
MINI_OP(OP_ADDCC, "addcc")
|
||||
MINI_OP(OP_ADDCC_IMM, "addcc_imm")
|
||||
MINI_OP(OP_SUBCC, "subcc")
|
||||
MINI_OP(OP_SUBCC_IMM, "subcc_imm")
|
||||
MINI_OP(OP_BR_REG, "br_reg")
|
||||
MINI_OP(OP_SEXT_I1, "sext_i1")
|
||||
MINI_OP(OP_SEXT_I2, "sext_i2")
|
||||
|
||||
+8
-23
@@ -209,7 +209,7 @@ mono_arch_get_global_int_regs (MonoCompile *cfg)
|
||||
if (cfg->frame_reg != ppc_sp)
|
||||
top = 31;
|
||||
#if USE_EXTRA_TEMPS
|
||||
top = 29;
|
||||
top -= 2;
|
||||
#endif
|
||||
for (i = 13; i < top; ++i)
|
||||
regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
|
||||
@@ -1296,11 +1296,7 @@ mono_spillvar_offset_float (MonoCompile *cfg, int spillvar)
|
||||
#undef DEBUG
|
||||
#define DEBUG(a) if (cfg->verbose_level > 1) a
|
||||
//#define DEBUG(a)
|
||||
/* use ppc_r3-ppc_10,ppc_r12 as temp registers, f1-f13 for FP registers */
|
||||
#define PPC_CALLER_REGS ((0xff<<3) | (1<<12) | USE_EXTRA_TEMPS)
|
||||
#define PPC_CALLER_FREGS (0x3ffe)
|
||||
|
||||
#define reg_is_freeable(r) (PPC_CALLER_REGS & 1 << (r))
|
||||
#define reg_is_freeable(r) ((r) >= 3 && (r) <= 10)
|
||||
#define freg_is_freeable(r) ((r) >= 1 && (r) <= 13)
|
||||
|
||||
typedef struct {
|
||||
@@ -1635,6 +1631,10 @@ alloc_int_reg (MonoCompile *cfg, InstList *curinst, MonoInst *ins, int sym_reg,
|
||||
return val;
|
||||
}
|
||||
|
||||
/* use ppc_r3-ppc_10,ppc_r12 as temp registers, f1-f13 for FP registers */
|
||||
#define PPC_CALLER_REGS ((0xff<<3) | (1<<12) | USE_EXTRA_TEMPS)
|
||||
#define PPC_CALLER_FREGS (0x3ffe)
|
||||
|
||||
/*
|
||||
* Local register allocation.
|
||||
* We first scan the list of instructions and we save the liveness info of
|
||||
@@ -2275,7 +2275,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
}
|
||||
// if (ins->cil_code)
|
||||
// g_print ("cil code\n");
|
||||
mono_debug_record_line_number (cfg, ins, offset);
|
||||
|
||||
switch (ins->opcode) {
|
||||
case OP_BIGMUL:
|
||||
@@ -2443,14 +2442,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case OP_ADC:
|
||||
ppc_adde (code, ins->dreg, ins->sreg1, ins->sreg2);
|
||||
break;
|
||||
case OP_ADDCC_IMM:
|
||||
if (ppc_is_imm16 (ins->inst_imm)) {
|
||||
ppc_addic (code, ins->dreg, ins->sreg1, ins->inst_imm);
|
||||
} else {
|
||||
ppc_load (code, ppc_r11, ins->inst_imm);
|
||||
ppc_addc (code, ins->dreg, ins->sreg1, ppc_r11);
|
||||
}
|
||||
break;
|
||||
case OP_ADD_IMM:
|
||||
if (ppc_is_imm16 (ins->inst_imm)) {
|
||||
ppc_addi (code, ins->dreg, ins->sreg1, ins->inst_imm);
|
||||
@@ -2530,10 +2521,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case OP_SUBCC:
|
||||
ppc_subfc (code, ins->dreg, ins->sreg2, ins->sreg1);
|
||||
break;
|
||||
case OP_SUBCC_IMM:
|
||||
ppc_load (code, ppc_r11, ins->inst_imm);
|
||||
ppc_subfc (code, ins->dreg, ppc_r11, ins->sreg1);
|
||||
break;
|
||||
case CEE_SUB:
|
||||
ppc_subf (code, ins->dreg, ins->sreg2, ins->sreg1);
|
||||
break;
|
||||
@@ -2551,7 +2538,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
break;
|
||||
case OP_SBB_IMM:
|
||||
ppc_load (code, ppc_r11, ins->inst_imm);
|
||||
ppc_subfe (code, ins->dreg, ppc_r11, ins->sreg1);
|
||||
ppc_subfe (code, ins->dreg, ins->sreg2, ppc_r11);
|
||||
break;
|
||||
case OP_PPC_SUBFIC:
|
||||
g_assert (ppc_is_imm16 (ins->inst_imm));
|
||||
@@ -2699,7 +2686,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
*/
|
||||
ppc_mulhwu (code, ppc_r0, ins->sreg1, ins->sreg2);
|
||||
ppc_cmpi (code, 0, 0, ppc_r0, 0);
|
||||
EMIT_COND_SYSTEM_EXCEPTION (CEE_BNE_UN - CEE_BEQ, "OverflowException");
|
||||
EMIT_COND_SYSTEM_EXCEPTION (CEE_BNE_UN - CEE_BEQ, ins->inst_p1);
|
||||
ppc_mullw (code, ins->dreg, ins->sreg1, ins->sreg2);
|
||||
break;
|
||||
case OP_ICONST:
|
||||
@@ -3422,8 +3409,6 @@ mono_arch_emit_prolog (MonoCompile *cfg)
|
||||
ArgInfo *ainfo = cinfo->args + i;
|
||||
inst = cfg->varinfo [pos];
|
||||
|
||||
if (cfg->verbose_level > 2)
|
||||
g_print ("Saving argument %d (type: %d)\n", i, ainfo->regtype);
|
||||
if (inst->opcode == OP_REGVAR) {
|
||||
if (ainfo->regtype == RegTypeGeneral)
|
||||
ppc_mr (code, inst->dreg, ainfo->reg);
|
||||
|
||||
@@ -2944,8 +2944,6 @@ guint8 cond;
|
||||
code = cfg->native_code + offset;
|
||||
}
|
||||
|
||||
mono_debug_record_line_number (cfg, ins, offset);
|
||||
|
||||
switch (ins->opcode) {
|
||||
case OP_STOREI1_MEMBASE_IMM: {
|
||||
s390_lhi (code, s390_r14, ins->inst_imm);
|
||||
@@ -3228,7 +3226,6 @@ guint8 cond;
|
||||
s390_alcr (code, ins->dreg, ins->sreg2);
|
||||
}
|
||||
break;
|
||||
case OP_ADDCC_IMM:
|
||||
case OP_ADD_IMM: {
|
||||
if ((ins->next) &&
|
||||
(ins->next->opcode == OP_ADC_IMM)) {
|
||||
@@ -3294,7 +3291,6 @@ guint8 cond;
|
||||
s390_slbr (code, ins->dreg, ins->sreg2);
|
||||
}
|
||||
break;
|
||||
case OP_SUBCC_IMM:
|
||||
case OP_SUB_IMM: {
|
||||
if (s390_is_imm16 (-ins->inst_imm)) {
|
||||
if (ins->dreg != ins->sreg1) {
|
||||
|
||||
@@ -2546,7 +2546,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
code_start = (guint8*)code;
|
||||
// if (ins->cil_code)
|
||||
// g_print ("cil code\n");
|
||||
mono_debug_record_line_number (cfg, ins, offset);
|
||||
|
||||
switch (ins->opcode) {
|
||||
case OP_STOREI1_MEMBASE_IMM:
|
||||
@@ -2652,7 +2651,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case CEE_ADD:
|
||||
sparc_add (code, FALSE, ins->sreg1, ins->sreg2, ins->dreg);
|
||||
break;
|
||||
case OP_ADDCC_IMM:
|
||||
case OP_ADD_IMM:
|
||||
/* according to inssel-long32.brg, this should set cc */
|
||||
EMIT_ALU_IMM (ins, add, TRUE);
|
||||
@@ -2670,7 +2668,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case CEE_SUB:
|
||||
sparc_sub (code, FALSE, ins->sreg1, ins->sreg2, ins->dreg);
|
||||
break;
|
||||
case OP_SUBCC_IMM:
|
||||
case OP_SUB_IMM:
|
||||
/* according to inssel-long32.brg, this should set cc */
|
||||
EMIT_ALU_IMM (ins, sub, TRUE);
|
||||
|
||||
@@ -1866,8 +1866,6 @@ mono_arch_local_regalloc (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
/* force source to be same as dest */
|
||||
rs->iassign [ins->sreg1] = ins->dreg;
|
||||
rs->iassign [ins->sreg1 + 1] = ins->unused;
|
||||
rs->isymbolic [ins->dreg] = ins->sreg1;
|
||||
rs->isymbolic [ins->unused] = ins->sreg1 + 1;
|
||||
|
||||
DEBUG (g_print ("\tassigned sreg1 (long) %s to sreg1 R%d\n", mono_arch_regname (ins->dreg), ins->sreg1));
|
||||
DEBUG (g_print ("\tassigned sreg1 (long-high) %s to sreg1 R%d\n", mono_arch_regname (ins->unused), ins->sreg1 + 1));
|
||||
@@ -2326,7 +2324,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case OP_ADC:
|
||||
x86_alu_reg_reg (code, X86_ADC, ins->sreg1, ins->sreg2);
|
||||
break;
|
||||
case OP_ADDCC_IMM:
|
||||
case OP_ADD_IMM:
|
||||
x86_alu_reg_imm (code, X86_ADD, ins->dreg, ins->inst_imm);
|
||||
break;
|
||||
@@ -2340,7 +2337,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
|
||||
case OP_SBB:
|
||||
x86_alu_reg_reg (code, X86_SBB, ins->sreg1, ins->sreg2);
|
||||
break;
|
||||
case OP_SUBCC_IMM:
|
||||
case OP_SUB_IMM:
|
||||
x86_alu_reg_imm (code, X86_SUB, ins->dreg, ins->inst_imm);
|
||||
break;
|
||||
|
||||
+25
-77
@@ -1581,24 +1581,23 @@ mono_compile_get_interface_var (MonoCompile *cfg, int slot, MonoInst *ins)
|
||||
*/
|
||||
static int
|
||||
handle_stack_args (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst **sp, int count) {
|
||||
int i, bindex;
|
||||
int i;
|
||||
MonoBasicBlock *outb;
|
||||
MonoInst *inst, **locals;
|
||||
gboolean found;
|
||||
|
||||
if (!count)
|
||||
return 0;
|
||||
if (cfg->verbose_level > 3)
|
||||
g_print ("%d item(s) on exit from B%d\n", count, bb->block_num);
|
||||
if (!bb->out_scount) {
|
||||
int found = 0;
|
||||
bb->out_scount = count;
|
||||
//g_print ("bblock %d has out:", bb->block_num);
|
||||
found = FALSE;
|
||||
for (i = 0; i < bb->out_count; ++i) {
|
||||
outb = bb->out_bb [i];
|
||||
//g_print (" %d", outb->block_num);
|
||||
if (outb->in_stack) {
|
||||
found = TRUE;
|
||||
found = 1;
|
||||
bb->out_stack = outb->in_stack;
|
||||
break;
|
||||
}
|
||||
@@ -1607,34 +1606,19 @@ handle_stack_args (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst **sp, int coun
|
||||
if (!found) {
|
||||
bb->out_stack = mono_mempool_alloc (cfg->mempool, sizeof (MonoInst*) * count);
|
||||
for (i = 0; i < count; ++i) {
|
||||
/*
|
||||
* try to reuse temps already allocated for this purpouse, if they occupy the same
|
||||
* stack slot and if they are of the same type.
|
||||
* This won't cause conflicts since if 'local' is used to
|
||||
* store one of the values in the in_stack of a bblock, then
|
||||
* the same variable will be used for the same outgoing stack
|
||||
* slot as well.
|
||||
* This doesn't work when inlining methods, since the bblocks
|
||||
* in the inlined methods do not inherit their in_stack from
|
||||
* the bblock they are inlined to. See bug #58863 for an
|
||||
* example.
|
||||
*/
|
||||
if (cfg->inlined_method)
|
||||
bb->out_stack [i] = mono_compile_create_var (cfg, type_from_stack_type (sp [i]), OP_LOCAL);
|
||||
else
|
||||
bb->out_stack [i] = mono_compile_get_interface_var (cfg, i, sp [i]);
|
||||
/* see bug#58863, but removing this code causes regressions in gtk-sharp build
|
||||
* (SEGV running Method::Initialize() in gapi_codegen.exe)
|
||||
*/
|
||||
#if 1
|
||||
/* try to reuse temps already allocated for this purpouse, if they occupy the same
|
||||
* stack slot and if they are of the same type. */
|
||||
bb->out_stack [i] = mono_compile_get_interface_var (cfg, i, sp [i]);
|
||||
#else
|
||||
bb->out_stack [i] = mono_compile_create_var (cfg, type_from_stack_type (sp [i]), OP_LOCAL);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < bb->out_count; ++i) {
|
||||
outb = bb->out_bb [i];
|
||||
if (outb->in_scount)
|
||||
continue; /* check they are the same locals */
|
||||
outb->in_scount = count;
|
||||
outb->in_stack = bb->out_stack;
|
||||
}
|
||||
|
||||
locals = bb->out_stack;
|
||||
for (i = 0; i < count; ++i) {
|
||||
/* add store ops at the end of the bb, before the branch */
|
||||
@@ -1649,36 +1633,14 @@ handle_stack_args (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst **sp, int coun
|
||||
if (cfg->verbose_level > 3)
|
||||
g_print ("storing %d to temp %d\n", i, locals [i]->inst_c0);
|
||||
}
|
||||
|
||||
/*
|
||||
* It is possible that the out bblocks already have in_stack assigned, and
|
||||
* the in_stacks differ. In this case, we will store to all the different
|
||||
* in_stacks.
|
||||
*/
|
||||
|
||||
found = TRUE;
|
||||
bindex = 0;
|
||||
while (found) {
|
||||
/* Find a bblock which has a different in_stack */
|
||||
found = FALSE;
|
||||
while (bindex < bb->out_count) {
|
||||
outb = bb->out_bb [bindex];
|
||||
if (outb->in_stack != locals) {
|
||||
/*
|
||||
* Instead of storing sp [i] to locals [i], we need to store
|
||||
* locals [i] to <new locals>[i], since the sp [i] tree can't
|
||||
* be shared between trees.
|
||||
*/
|
||||
for (i = 0; i < count; ++i)
|
||||
mono_add_varcopy_to_end (cfg, bb, locals [i]->inst_c0, outb->in_stack [i]->inst_c0);
|
||||
locals = outb->in_stack;
|
||||
found = TRUE;
|
||||
break;
|
||||
}
|
||||
bindex ++;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < bb->out_count; ++i) {
|
||||
outb = bb->out_bb [i];
|
||||
if (outb->in_scount)
|
||||
continue; /* check they are the same locals */
|
||||
outb->in_scount = count;
|
||||
outb->in_stack = locals;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -2465,7 +2427,6 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
|
||||
MonoMethodHeader *cheader;
|
||||
MonoBasicBlock *ebblock, *sbblock;
|
||||
int i, costs, new_locals_offset;
|
||||
MonoMethod *prev_inlined_method;
|
||||
|
||||
if (cfg->verbose_level > 2)
|
||||
g_print ("INLINE START %p %s -> %s\n", cmethod, mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
|
||||
@@ -2494,13 +2455,8 @@ inline_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig,
|
||||
ebblock->block_num = cfg->num_bblocks++;
|
||||
ebblock->real_offset = real_offset;
|
||||
|
||||
prev_inlined_method = cfg->inlined_method;
|
||||
cfg->inlined_method = cmethod;
|
||||
|
||||
costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, new_locals_offset, rvar, dont_inline, sp, real_offset, *ip == CEE_CALLVIRT);
|
||||
|
||||
cfg->inlined_method = prev_inlined_method;
|
||||
|
||||
if ((costs >= 0 && costs < 60) || inline_allways) {
|
||||
if (cfg->verbose_level > 2)
|
||||
g_print ("INLINE END %s -> %s\n", mono_method_full_name (cfg->method, TRUE), mono_method_full_name (cmethod, TRUE));
|
||||
@@ -3893,13 +3849,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
|
||||
CHECK_OPSIZE (5);
|
||||
n = read32 (ip + 1);
|
||||
|
||||
if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
|
||||
NEW_PCONST (cfg, ins, mono_method_get_wrapper_data (method, n));
|
||||
ins->cil_code = ip;
|
||||
ins->type = STACK_OBJ;
|
||||
*sp = ins;
|
||||
}
|
||||
else if (method->wrapper_type != MONO_WRAPPER_NONE) {
|
||||
if (method->wrapper_type != MONO_WRAPPER_NONE) {
|
||||
int temp;
|
||||
MonoInst *iargs [1];
|
||||
|
||||
@@ -7096,12 +7046,10 @@ optimize_branches (MonoCompile *cfg)
|
||||
bbn->code->inst_target_bb->region == bb->region) {
|
||||
|
||||
if (cfg->verbose_level > 2)
|
||||
g_print ("in %s branch to branch triggered %d -> %d -> %d\n", cfg->method->name,
|
||||
bb->block_num, bbn->block_num, bbn->code->inst_target_bb->block_num);
|
||||
|
||||
replace_in_block (bbn, bb, NULL);
|
||||
replace_out_block (bb, bbn, bbn->code->inst_target_bb);
|
||||
link_bblock (cfg, bb, bbn->code->inst_target_bb);
|
||||
g_print ("in %s branch to branch triggered %d -> %d\n", cfg->method->name,
|
||||
bb->block_num, bbn->block_num);
|
||||
|
||||
replace_basic_block (bb, bb->out_bb [0], bbn->code->inst_target_bb);
|
||||
bb->last_ins->inst_target_bb = bbn->code->inst_target_bb;
|
||||
changed = TRUE;
|
||||
break;
|
||||
|
||||
@@ -492,7 +492,6 @@ typedef struct {
|
||||
MonoSpillInfo *spill_info_float; /* fp register spills */
|
||||
gint spill_count;
|
||||
/* unsigned char *cil_code; */
|
||||
MonoMethod *inlined_method; /* the method which is currently inlined */
|
||||
|
||||
/* the exception object passed to catch/filter blocks */
|
||||
MonoInst *exvar;
|
||||
|
||||
@@ -1,9 +1,3 @@
|
||||
2004-09-07 Duncan Mak <[email protected]>
|
||||
|
||||
* typeof-ptr.cs: Add unsafe sections to the code that's using
|
||||
pointers directly. This was breaking the test stage on the build
|
||||
boxes.
|
||||
|
||||
2004-05-29 Zoltan Varga <[email protected]>
|
||||
|
||||
* invoke.cs: Add an Invoke test.
|
||||
|
||||
@@ -41,7 +41,6 @@ TEST_CS_SRC= \
|
||||
exception16.cs \
|
||||
struct.cs \
|
||||
valuetype-gettype.cs \
|
||||
typeof-ptr.cs \
|
||||
static-constructor.cs \
|
||||
pinvoke.cs \
|
||||
pinvoke1.cs \
|
||||
|
||||
@@ -636,24 +636,10 @@ mono_test_marshal_primitive_byref_delegate (PrimitiveByrefDelegate delegate)
|
||||
return 0;
|
||||
}
|
||||
|
||||
typedef int (*return_int_delegate) (int i);
|
||||
|
||||
typedef return_int_delegate (*ReturnDelegateDelegate) ();
|
||||
|
||||
int
|
||||
mono_test_marshal_return_delegate_delegate (ReturnDelegateDelegate d)
|
||||
{
|
||||
return (d ()) (55);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
mono_test_marshal_stringbuilder (char *s, int n)
|
||||
{
|
||||
const char m[] = "This is my message. Isn't it nice?";
|
||||
|
||||
if (strcmp (s, "ABCD") != 0)
|
||||
return 1;
|
||||
strncpy(s, m, n);
|
||||
return 0;
|
||||
}
|
||||
@@ -700,20 +686,6 @@ mono_test_marshal_string_array (char **array)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
mono_test_marshal_stringbuilder_array (char **array)
|
||||
{
|
||||
if (strcmp (array [0], "ABC"))
|
||||
return 1;
|
||||
if (strcmp (array [1], "DEF"))
|
||||
return 2;
|
||||
|
||||
strcpy (array [0], "DEF");
|
||||
strcpy (array [1], "ABC");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
mono_test_marshal_unicode_string_array (gunichar2 **array, char **array2)
|
||||
{
|
||||
@@ -1019,18 +991,6 @@ mono_test_marshal_mixed_point (mixed_point pt)
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
mono_test_marshal_mixed_point_2 (mixed_point *pt)
|
||||
{
|
||||
if (pt->x != 5 || pt->y != 6.75)
|
||||
return 1;
|
||||
|
||||
pt->x = 10;
|
||||
pt->y = 12.35;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
time_t_sizeof (void)
|
||||
{
|
||||
|
||||
@@ -111,9 +111,6 @@ public class Tests {
|
||||
[DllImport ("libtest", EntryPoint="mono_test_marshal_unicode_string_array", CharSet=CharSet.Unicode)]
|
||||
public static extern int mono_test_marshal_unicode_string_array (string [] a1, [MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.LPStr)]string [] a2);
|
||||
|
||||
[DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_array")]
|
||||
public static extern int mono_test_marshal_stringbuilder_array (StringBuilder [] a1);
|
||||
|
||||
[DllImport ("libtest", EntryPoint="mono_test_marshal_inout_array")]
|
||||
public static extern int mono_test_marshal_inout_array ([In, Out] int [] a1);
|
||||
|
||||
@@ -416,7 +413,6 @@ public class Tests {
|
||||
|
||||
static int test_0_marshal_stringbuilder () {
|
||||
StringBuilder sb = new StringBuilder(255);
|
||||
sb.Append ("ABCD");
|
||||
mono_test_marshal_stringbuilder (sb, sb.Capacity);
|
||||
String res = sb.ToString();
|
||||
|
||||
@@ -449,20 +445,6 @@ public class Tests {
|
||||
return mono_test_marshal_unicode_string_array (new String [] { "ABC", "DEF" }, new String [] { "ABC", "DEF" });
|
||||
}
|
||||
|
||||
static int test_0_marshal_stringbuilder_array () {
|
||||
StringBuilder sb1 = new StringBuilder ("ABC");
|
||||
StringBuilder sb2 = new StringBuilder ("DEF");
|
||||
|
||||
int res = mono_test_marshal_stringbuilder_array (new StringBuilder [] { sb1, sb2 });
|
||||
if (res != 0)
|
||||
return res;
|
||||
if (sb1.ToString () != "DEF")
|
||||
return 5;
|
||||
if (sb2.ToString () != "ABC")
|
||||
return 6;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int test_0_last_error () {
|
||||
mono_test_last_error (5);
|
||||
if (Marshal.GetLastWin32Error () == 5)
|
||||
|
||||
Loaded 100 of 105 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user