public static IEnumerable <TokenInfo> GetTokens(string text, params char[] separators)
{
unsafe
{
string *ptr = null;
}
}
static void Main(string[] args)
{
string *a = "Hello";
string b = "Hello";
int aAdd = &a;
Console.WriteLine("{0}", &a);
Console.WriteLine("{0}", &b);
}
public unsafe bool WriteEvent(ref EventDescriptor eventDescriptor, EventTraceActivity eventTraceActivity, string data)
{
uint num = 0;
string str = data;
string empty = str;
if (str == null)
{
empty = string.Empty;
}
data = empty;
if (this.IsEnabled(eventDescriptor.Level, eventDescriptor.Keywords))
{
if (data.Length <= 0x7fd4)
{
if (eventTraceActivity != null)
{
DiagnosticsEventProvider.SetActivityId(ref eventTraceActivity.ActivityId);
}
UnsafeNativeMethods.EventData length;
length.Size = (data.Length + 1) * 2;
length.Reserved = 0;
fixed(string str1 = data)
{
string *strPointers = &str1;
char * offsetToStringData = (char *)(&str1);
if (&str1 != null)
{
offsetToStringData = (char *)(strPointers + RuntimeHelpers.OffsetToStringData);
}
length.DataPointer = (ulong)offsetToStringData;
num = UnsafeNativeMethods.EventWrite(this.traceRegistrationHandle, ref eventDescriptor, 1, ref length);
}
}
else
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
}
if (num == 0)
{
return(true);
}
else
{
DiagnosticsEventProvider.SetLastError(num);
return(false);
}
}
public static unsafe SecureString ToSecureString(this string unsecureString)
{
if (unsecureString == null)
{
return(null);
}
fixed(string str = unsecureString)
{
string *offsetToStringData = &str;
if (offsetToStringData != null)
{
offsetToStringData = offsetToStringData + RuntimeHelpers.OffsetToStringData;
}
SecureString secureString = new SecureString((char *)offsetToStringData, unsecureString.Length);
secureString.MakeReadOnly();
return(secureString);
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="CMap<int"></param>
/// <param name="enummap"></param>
/// <param name="value"></param>
/// <returns></returns>
/// <created>UPh,11.11.2013</created>
/// <changed>UPh,11.11.2013</changed>
// ********************************************************************************
/* TODO
*
* bool GetEnumAttribute(string name, XmlEnumMap &enummap, int *value)
* {
* TCHAR text[80] = _T("");
* if (GetAttribute(name, text, _countof(text)))
* {
* for (std::pair<string, int> c : enummap)
* {
* if (_tcscmp(c.first, text) == 0)
* {
* value = c.second;
* return true;
* }
* }
*
* if (_istdigit(text[0]))
* {
* value = _ttoi(text);
* return true;
* }
*
* ASSERT(0); // invalid enum
* }
*
* value = 0;
* return false;
* }
*/
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="time"></param>
/// <returns></returns>
/// <created>UPh,01.04.2014</created>
/// <changed>UPh,01.04.2014</changed>
// ********************************************************************************
/* TODO
* bool GetTimeAttribute(string name, CFileTime *time)
* {
* TCHAR text[80] = _T("");
* if (GetAttribute(name, text, _countof(text)))
* {
* CTMFileTime t;
* if (t.ScanIsoDateTime(text, true))
* {
* time.SetTime(t.m_Int);
* return true;
* }
* }
*
* time.SetTime(0);
* return false;
* }
*/
#if false
//********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="def"></param>
/// <returns></returns>
/// <created>UPh,08.04.2013</created>
/// <changed>UPh,08.04.2013</changed>
//********************************************************************************
bool SerializeAttribute(string name, string *value, string def /*= null*/)
{
if (IsReading())
{
if (def == null)
{
def = _T("");
}
if (!GetAttribute(name, value))
{
*value = def;
}
return(true);
}
else if (IsWriting())
{
WriteAttribute(name, *value);
return(true);
}
return(false);
}
static void Main()
{
var point = new Point {
X = 1, Y = 2, Z = 2
};
#if Uncompilable
string s = "abc";
#endif
unsafe
{
// ジェネリックでなければ、Point は元からポインター化可能。
Point *p = &point;
#if Uncompilable
// これはダメ。
// 参照型のポインターは作れない。
string *ps = &s;
#endif
}
MemSet0(ref point);
Console.WriteLine(point); // (0, 0, 0)
#if Uncompilable
// これはダメ。
// MemSet0<T> の T に unmanaged 制約が付いてるので、string では呼べない
MemSet0(ref s);
#endif
#if Uncompilable
// これもダメ。
// unmanaged な型だけを含む構造体なので、原理的にはポインター化しても安全なんだけど。
// 再帰的なジェネリック型に対して安全保証するのはメリットの割に大変らしく、断念したとのこと。
var kv = new KeyValuePair <int, Point>(1, point);
MemSet0(ref kv);
#endif
}
public unsafe bool WriteMessageEvent(string eventMessage, byte eventLevel, long eventKeywords)
{
int num = 0;
if (eventMessage == null)
{
throw Fx.Exception.AsError(new ArgumentNullException("eventMessage"), null);
}
if (this.IsEnabled(eventLevel, eventKeywords))
{
if (eventMessage.Length > 32724)
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
fixed(string str = eventMessage)
{
string *offsetToStringData = &str;
if (offsetToStringData != null)
{
offsetToStringData = offsetToStringData + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer = (char *)offsetToStringData;
num = (int)UnsafeNativeMethods.EventWriteString(this.traceRegistrationHandle, eventLevel, eventKeywords, chrPointer);
}
if (num != 0)
{
DiagnosticsEventProvider.SetLastError(num);
return(false);
}
}
return(true);
}
public unsafe bool WriteMessageEvent(EventTraceActivity eventTraceActivity, string eventMessage, byte eventLevel, long eventKeywords)
{
if (eventMessage != null)
{
if (eventTraceActivity != null)
{
DiagnosticsEventProvider.SetActivityId(ref eventTraceActivity.ActivityId);
}
if (this.IsEnabled(eventLevel, eventKeywords))
{
if (eventMessage.Length <= 0x7fd4)
{
fixed(string str = eventMessage)
{
string *strPointers = &str;
char * offsetToStringData = (char *)(&str);
if (&str != null)
{
offsetToStringData = (char *)(strPointers + RuntimeHelpers.OffsetToStringData);
}
int num = UnsafeNativeMethods.EventWriteString(this.traceRegistrationHandle, eventLevel, eventKeywords, offsetToStringData);
}
}
else
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
}
return(true);
}
else
{
throw Fx.Exception.AsError(new ArgumentNullException("eventMessage"));
}
}
public unsafe bool WriteEvent(ref EventDescriptor eventDescriptor, string data)
{
UnsafeNativeMethods.EventData length = new UnsafeNativeMethods.EventData();
uint num = 0;
data = data ?? string.Empty;
if (this.IsEnabled(eventDescriptor.Level, eventDescriptor.Keywords))
{
if (data.Length > 32724)
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
Guid activityId = DiagnosticsEventProvider.GetActivityId();
DiagnosticsEventProvider.SetActivityId(ref activityId);
length.Size = (uint)((data.Length + 1) * 2);
length.Reserved = 0;
fixed(string str = data)
{
string *offsetToStringData = &str;
if (offsetToStringData != null)
{
offsetToStringData = offsetToStringData + RuntimeHelpers.OffsetToStringData;
}
length.DataPointer = (ulong)((char *)offsetToStringData);
num = UnsafeNativeMethods.EventWrite(this.traceRegistrationHandle, ref eventDescriptor, 1, ref length);
}
}
if (num == 0)
{
return(true);
}
DiagnosticsEventProvider.SetLastError((int)num);
return(false);
}
public unsafe bool WriteTransferEvent(ref EventDescriptor eventDescriptor, Guid relatedActivityId, params object[] eventPayload)
{
uint num = 0;
if (this.IsEnabled(eventDescriptor.Level, eventDescriptor.Keywords))
{
Guid activityId = DiagnosticsEventProvider.GetActivityId();
if (eventPayload == null || (int)eventPayload.Length == 0)
{
num = UnsafeNativeMethods.EventWriteTransfer(this.traceRegistrationHandle, ref eventDescriptor, ref activityId, ref relatedActivityId, 0, 0);
}
else
{
int length = (int)eventPayload.Length;
if (length > 32)
{
throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", SRCore.EtwMaxNumberArgumentsExceeded(32)), null);
}
uint size = 0;
int num1 = 0;
int[] numArray = new int[8];
string[] strArrays = new string[8];
UnsafeNativeMethods.EventData *eventDataPointer = stackalloc UnsafeNativeMethods.EventData[checked (length * sizeof(UnsafeNativeMethods.EventData))];
UnsafeNativeMethods.EventData *eventDataPointer1 = eventDataPointer;
byte *numPointer = stackalloc byte[16 * length];
for (int i = 0; i < (int)eventPayload.Length; i++)
{
if (eventPayload[i] != null)
{
string str = DiagnosticsEventProvider.EncodeObject(ref eventPayload[i], eventDataPointer1, numPointer);
numPointer = numPointer + 16;
size = size + (*eventDataPointer1).Size;
eventDataPointer1 = eventDataPointer1 + sizeof(UnsafeNativeMethods.EventData);
if (str != null)
{
if (num1 >= 8)
{
throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", SRCore.EtwAPIMaxStringCountExceeded(8)), null);
}
strArrays[num1] = str;
numArray[num1] = i;
num1++;
}
}
}
if (size > 65482)
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
fixed(string str1 = strArrays[0])
{
string *offsetToStringData = &str1;
if (offsetToStringData != null)
{
offsetToStringData = offsetToStringData + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer = (char *)offsetToStringData;
fixed(string str2 = strArrays[1])
{
string *strPointers = &str2;
if (strPointers != null)
{
strPointers = strPointers + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer1 = (char *)strPointers;
fixed(string str3 = strArrays[2])
{
string *offsetToStringData1 = &str3;
if (offsetToStringData1 != null)
{
offsetToStringData1 = offsetToStringData1 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer2 = (char *)offsetToStringData1;
fixed(string str4 = strArrays[3])
{
string *strPointers1 = &str4;
if (strPointers1 != null)
{
strPointers1 = strPointers1 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer3 = (char *)strPointers1;
fixed(string str5 = strArrays[4])
{
string *offsetToStringData2 = &str5;
if (offsetToStringData2 != null)
{
offsetToStringData2 = offsetToStringData2 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer4 = (char *)offsetToStringData2;
fixed(string str6 = strArrays[5])
{
string *strPointers2 = &str6;
if (strPointers2 != null)
{
strPointers2 = strPointers2 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer5 = (char *)strPointers2;
fixed(string str7 = strArrays[6])
{
string *offsetToStringData3 = &str7;
if (offsetToStringData3 != null)
{
offsetToStringData3 = offsetToStringData3 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer6 = (char *)offsetToStringData3;
fixed(string str8 = strArrays[7])
{
string *strPointers3 = &str8;
if (strPointers3 != null)
{
strPointers3 = strPointers3 + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer7 = (char *)strPointers3;
eventDataPointer1 = eventDataPointer;
if (strArrays[0] != null)
{
(*(eventDataPointer1 + numArray[0] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer;
}
if (strArrays[1] != null)
{
(*(eventDataPointer1 + numArray[1] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer1;
}
if (strArrays[2] != null)
{
(*(eventDataPointer1 + numArray[2] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer2;
}
if (strArrays[3] != null)
{
(*(eventDataPointer1 + numArray[3] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer3;
}
if (strArrays[4] != null)
{
(*(eventDataPointer1 + numArray[4] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer4;
}
if (strArrays[5] != null)
{
(*(eventDataPointer1 + numArray[5] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer5;
}
if (strArrays[6] != null)
{
(*(eventDataPointer1 + numArray[6] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer6;
}
if (strArrays[7] != null)
{
(*(eventDataPointer1 + numArray[7] * sizeof(UnsafeNativeMethods.EventData))).DataPointer = (ulong)chrPointer7;
}
num = UnsafeNativeMethods.EventWriteTransfer(this.traceRegistrationHandle, ref eventDescriptor, ref activityId, ref relatedActivityId, (uint)length, eventDataPointer);
}
}
}
}
}
}
}
}
str2 = null;
str3 = null;
str4 = null;
str5 = null;
str6 = null;
str7 = null;
str8 = null;
}
}
if (num == 0)
{
return(true);
}
DiagnosticsEventProvider.SetLastError((int)num);
return(false);
}
internal static unsafe int InitializeSecurityContext(SafeFreeCredentials inCredentials, ref SafeDeleteContext refContext, string targetName, SspiContextFlags inFlags, Endianness endianness, SecurityBuffer inSecBuffer, SecurityBuffer[] inSecBuffers, SecurityBuffer outSecBuffer, ref SspiContextFlags outFlags)
{
IntPtr *intPtrPointer;
IntPtr *intPtrPointer1;
if (inCredentials == null)
{
throw new ArgumentNullException("inCredentials");
}
SecurityBufferDescriptor securityBufferDescriptor = null;
if (inSecBuffer != null)
{
securityBufferDescriptor = new SecurityBufferDescriptor(1);
}
else if (inSecBuffers != null)
{
securityBufferDescriptor = new SecurityBufferDescriptor((int)inSecBuffers.Length);
}
SecurityBufferDescriptor securityBufferDescriptor1 = new SecurityBufferDescriptor(1);
bool flag = ((inFlags & SspiContextFlags.AllocateMemory) != SspiContextFlags.Zero ? true : false);
int num = -1;
SSPIHandle sSPIHandle = new SSPIHandle();
if (refContext != null)
{
sSPIHandle = refContext._handle;
}
GCHandle[] gCHandleArray = null;
GCHandle gCHandle = new GCHandle();
SafeFreeContextBuffer safeFreeContextBuffer = null;
try
{
gCHandle = GCHandle.Alloc(outSecBuffer.token, GCHandleType.Pinned);
SecurityBufferStruct[] zero = new SecurityBufferStruct[(securityBufferDescriptor == null ? 1 : securityBufferDescriptor.Count)];
try
{
SecurityBufferStruct[] securityBufferStructArray = zero;
SecurityBufferStruct[] securityBufferStructArray1 = securityBufferStructArray;
if (securityBufferStructArray == null || (int)securityBufferStructArray1.Length == 0)
{
intPtrPointer = null;
}
else
{
intPtrPointer = &securityBufferStructArray1[0];
}
if (securityBufferDescriptor != null)
{
securityBufferDescriptor.UnmanagedPointer = (void *)intPtrPointer;
gCHandleArray = new GCHandle[securityBufferDescriptor.Count];
for (int i = 0; i < securityBufferDescriptor.Count; i++)
{
SecurityBuffer securityBuffer = (inSecBuffer != null ? inSecBuffer : inSecBuffers[i]);
if (securityBuffer != null)
{
zero[i].count = securityBuffer.size;
zero[i].type = securityBuffer.type;
if (securityBuffer.unmanagedToken != null)
{
zero[i].token = securityBuffer.unmanagedToken.DangerousGetHandle();
}
else if (securityBuffer.token == null || (int)securityBuffer.token.Length == 0)
{
zero[i].token = IntPtr.Zero;
}
else
{
gCHandleArray[i] = GCHandle.Alloc(securityBuffer.token, GCHandleType.Pinned);
zero[i].token = Marshal.UnsafeAddrOfPinnedArrayElement(securityBuffer.token, securityBuffer.offset);
}
}
}
}
SecurityBufferStruct[] zero1 = new SecurityBufferStruct[1];
try
{
SecurityBufferStruct[] securityBufferStructArray2 = zero1;
SecurityBufferStruct[] securityBufferStructArray3 = securityBufferStructArray2;
if (securityBufferStructArray2 == null || (int)securityBufferStructArray3.Length == 0)
{
intPtrPointer1 = null;
}
else
{
intPtrPointer1 = &securityBufferStructArray3[0];
}
securityBufferDescriptor1.UnmanagedPointer = (void *)intPtrPointer1;
zero1[0].count = outSecBuffer.size;
zero1[0].type = outSecBuffer.type;
if (outSecBuffer.token == null || (int)outSecBuffer.token.Length == 0)
{
zero1[0].token = IntPtr.Zero;
}
else
{
zero1[0].token = Marshal.UnsafeAddrOfPinnedArrayElement(outSecBuffer.token, outSecBuffer.offset);
}
if (flag)
{
safeFreeContextBuffer = SafeFreeContextBuffer.CreateEmptyHandle();
}
if (refContext == null || refContext.IsInvalid)
{
refContext = new SafeDeleteContext();
}
if (targetName == null || targetName.Length == 0)
{
targetName = " ";
}
try
{
fixed(string str = targetName)
{
string *offsetToStringData = &str;
if (offsetToStringData != null)
{
offsetToStringData = offsetToStringData + RuntimeHelpers.OffsetToStringData;
}
char *chrPointer = (char *)offsetToStringData;
num = SafeDeleteContext.MustRunInitializeSecurityContext(inCredentials, (sSPIHandle.IsZero ? (void *)0 : (void *)(&sSPIHandle)), ((object)targetName == (object)" " ? (byte *)0 : (byte *)chrPointer), inFlags, endianness, securityBufferDescriptor, refContext, securityBufferDescriptor1, ref outFlags, safeFreeContextBuffer);
}
}
finally
{
str = null;
}
outSecBuffer.size = zero1[0].count;
outSecBuffer.type = zero1[0].type;
if (outSecBuffer.size <= 0)
{
outSecBuffer.token = null;
}
else
{
outSecBuffer.token = new byte[outSecBuffer.size];
Marshal.Copy(zero1[0].token, outSecBuffer.token, 0, outSecBuffer.size);
}
}
finally
{
intPtrPointer1 = null;
}
}
finally
{
intPtrPointer = null;
}
}
finally
{
if (gCHandleArray != null)
{
for (int j = 0; j < (int)gCHandleArray.Length; j++)
{
if (gCHandleArray[j].IsAllocated)
{
gCHandleArray[j].Free();
}
}
}
if (gCHandle.IsAllocated)
{
gCHandle.Free();
}
if (safeFreeContextBuffer != null)
{
safeFreeContextBuffer.Close();
}
}
return(num);
}
void ParseProgram()
{
string p;
if (!this.stateProgram || !*this.stateProgram)
{
return;
}
if (_interpreterData) // previous script
{
delete(TrainInterpreterData) _interpreterData;
}
_interpreterData = new TrainInterpreterData;
TrainInterpreterData *interp = (TrainInterpreterData *)_interpreterData;
p = this.stateProgram;
while (*p)
{
const string *p1 = p;
while (*p1 == ' ' || *p1 == '\t' || *p1 == '\r' || *p1 == '\n')
{
++p1;
}
p = p1;
if (match(&p, wxPorting.T("OnInit:")))
{
p1 = p;
interp._onInit = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnEntry:")))
{
p = next_token(p);
p1 = p;
interp._onEntry = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnExit:")))
{
p = next_token(p);
p1 = p;
interp._onExit = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnStop:")))
{
p = next_token(p);
p1 = p;
interp._onStop = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnWaiting:")))
{
p = next_token(p);
p1 = p;
interp._onWaiting = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnStart:")))
{
p = next_token(p);
p1 = p;
interp._onStart = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnAssign:")))
{
p = next_token(p);
p1 = p;
interp._onAssign = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnArrived:")))
{
p = next_token(p);
p1 = p;
interp._onArrived = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnReverse:")))
{
p = next_token(p);
p1 = p;
interp._onReverse = ParseStatements(&p);
}
else if (match(&p, wxPorting.T("OnShunt:")))
{
p = next_token(p);
p1 = p;
interp._onShunt = ParseStatements(&p);
}
if (p1 == p) // error! couldn't parse token
{
break;
}
}
}
public unsafe bool WriteTransferEvent(ref EventDescriptor eventDescriptor, EventTraceActivity eventTraceActivity, Guid relatedActivityId, object[] eventPayload)
{
if (eventTraceActivity == null)
{
eventTraceActivity = EventTraceActivity.Empty;
}
uint num = 0;
if (this.IsEnabled(eventDescriptor.Level, eventDescriptor.Keywords))
{
if (eventPayload == null || (int)eventPayload.Length == 0)
{
num = UnsafeNativeMethods.EventWriteTransfer(this.traceRegistrationHandle, ref eventDescriptor, ref eventTraceActivity.ActivityId, ref relatedActivityId, 0, 0);
}
else
{
int length = (int)eventPayload.Length;
if (length <= 32)
{
uint size = 0;
int num1 = 0;
int[] numArray = new int[8];
string[] strArrays = new string[8];
UnsafeNativeMethods.EventData *eventDataPointer = (UnsafeNativeMethods.EventData *)length * sizeof(UnsafeNativeMethods.EventData);
UnsafeNativeMethods.EventData *eventDataPointer1 = eventDataPointer;
byte *numPointer = (byte *)16 * length;
byte *numPointer1 = numPointer;
for (int i = 0; i < (int)eventPayload.Length; i++)
{
if (eventPayload[i] != null)
{
string str = DiagnosticsEventProvider.EncodeObject(ref eventPayload[i], eventDataPointer1, numPointer1);
numPointer1 = numPointer1 + 16;
size = size + (*(eventDataPointer1)).Size;
eventDataPointer1 = (UnsafeNativeMethods.EventData *)(eventDataPointer1 + sizeof(UnsafeNativeMethods.EventData));
if (str != null)
{
if (num1 >= 8)
{
throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", InternalSR.EtwAPIMaxStringCountExceeded(8)));
}
else
{
strArrays[num1] = str;
numArray[num1] = i;
num1++;
}
}
}
}
if (size <= 0xffca)
{
fixed(string str1 = strArrays[0])
{
string *strPointers = &str1;
char * offsetToStringData = (char *)(&str1);
if (&str1 != null)
{
offsetToStringData = (char *)(strPointers + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer = offsetToStringData;
fixed(string str2 = strArrays[1])
{
string *strPointers1 = &str2;
char * offsetToStringData1 = (char *)(&str2);
if (&str2 != null)
{
offsetToStringData1 = (char *)(strPointers1 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer1 = offsetToStringData1;
fixed(string str3 = strArrays[2])
{
string *strPointers2 = &str3;
char * offsetToStringData2 = (char *)(&str3);
if (&str3 != null)
{
offsetToStringData2 = (char *)(strPointers2 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer2 = offsetToStringData2;
fixed(string str4 = strArrays[3])
{
string *strPointers3 = &str4;
char * offsetToStringData3 = (char *)(&str4);
if (&str4 != null)
{
offsetToStringData3 = (char *)(strPointers3 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer3 = offsetToStringData3;
fixed(string str5 = strArrays[4])
{
string *strPointers4 = &str5;
char * offsetToStringData4 = (char *)(&str5);
if (&str5 != null)
{
offsetToStringData4 = (char *)(strPointers4 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer4 = offsetToStringData4;
fixed(string str6 = strArrays[5])
{
string *strPointers5 = &str6;
char * offsetToStringData5 = (char *)(&str6);
if (&str6 != null)
{
offsetToStringData5 = (char *)(strPointers5 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer5 = offsetToStringData5;
fixed(string str7 = strArrays[6])
{
string *strPointers6 = &str7;
char * offsetToStringData6 = (char *)(&str7);
if (&str7 != null)
{
offsetToStringData6 = (char *)(strPointers6 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer6 = offsetToStringData6;
fixed(string str8 = strArrays[7])
{
string *strPointers7 = &str8;
char * offsetToStringData7 = (char *)(&str8);
if (&str8 != null)
{
offsetToStringData7 = (char *)(strPointers7 + RuntimeHelpers.OffsetToStringData);
}
char *chrPointer7 = offsetToStringData7;
eventDataPointer1 = eventDataPointer;
if (strArrays[0] != null)
{
(eventDataPointer1 + numArray[0] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer;
}
if (strArrays[1] != null)
{
(eventDataPointer1 + numArray[1] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer1;
}
if (strArrays[2] != null)
{
(eventDataPointer1 + numArray[2] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer2;
}
if (strArrays[3] != null)
{
(eventDataPointer1 + numArray[3] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer3;
}
if (strArrays[4] != null)
{
(eventDataPointer1 + numArray[4] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer4;
}
if (strArrays[5] != null)
{
(eventDataPointer1 + numArray[5] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer5;
}
if (strArrays[6] != null)
{
(eventDataPointer1 + numArray[6] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer6;
}
if (strArrays[7] != null)
{
(eventDataPointer1 + numArray[7] * sizeof(UnsafeNativeMethods.EventData)).DataPointer = (ulong)chrPointer7;
}
num = UnsafeNativeMethods.EventWriteTransfer(this.traceRegistrationHandle, ref eventDescriptor, ref eventTraceActivity.ActivityId, ref relatedActivityId, length, eventDataPointer);
}
}
}
}
}
}
}
}
}
else
{
DiagnosticsEventProvider.errorCode = DiagnosticsEventProvider.WriteEventErrorCode.EventTooBig;
return(false);
}
}
else
{
throw Fx.Exception.AsError(new ArgumentOutOfRangeException("eventPayload", InternalSR.EtwMaxNumberArgumentsExceeded(32)));
}
}
}
if (num == 0)
{
return(true);
}
else
{
DiagnosticsEventProvider.SetLastError(num);
return(false);
}
}
unsafe public static void Main()
{
string s = "dfg";
string *ptrS = &s;
}
