Ejemplo n.º 1
0
        static void _CustomWriteMicrosoftStyleWithOffset_ThunkWriter(ref ThunkWriter writer, long utcTicks, int hours, int minutes, char[] buffer)
        {
            const long EpochTicks = 621355968000000000L;
            const long TicksToMilliseconds = 10000L;

            writer.WriteValueConstant(ConstantString_Value.Date);

            var delta = (utcTicks - EpochTicks) / TicksToMilliseconds;
            _CustomWriteLong_ThunkWriter(ref writer, delta, buffer);

            if (hours < 0 || minutes < 0)
            {
                writer.Write('-');
                hours = -hours;
                minutes = -minutes;
            }
            else
            {
                writer.Write('+');
            }

            var digits = DigitPairs[hours];
            writer.Write(digits.First);
            writer.Write(digits.Second);

            digits = DigitPairs[minutes];
            writer.Write(digits.First);
            writer.Write(digits.Second);

            writer.WriteValueConstant(ConstantString_Value.CloseDate);
        }
Ejemplo n.º 2
0
        static unsafe void _WriteEncodedStringWithNullsInlineUnsafe_ThunkWriter(ref ThunkWriter writer, string strRef)
        {
            if (strRef == null)
            {
                writer.WriteValueConstant(ConstantString_Value.Null);
                return;
            }

            fixed (char* strFixed = strRef)
            {
                char* str = strFixed;
                char c;
                var len = strRef.Length;

                while (len > 0)
                {
                    c = *str;
                    str++;
                    len--;

                    if (c == '\\')
                    {
                        writer.WriteCommonConstant(ConstantString_Common.DoubleBackSlash);
                        continue;
                    }

                    if (c == '"')
                    {
                        writer.WriteFormattingConstant(ConstantString_Formatting.BackSlashQuote);
                        continue;
                    }

                    // This is converted into an IL switch, so don't fret about lookup times
                    switch (c)
                    {
                        case '\u0000': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0000); continue;
                        case '\u0001': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0001); continue;
                        case '\u0002': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0002); continue;
                        case '\u0003': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0003); continue;
                        case '\u0004': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0004); continue;
                        case '\u0005': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0005); continue;
                        case '\u0006': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0006); continue;
                        case '\u0007': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_0007); continue;
                        case '\u0008': writer.WriteCommonConstant(ConstantString_Common.EscapeSequence_b); continue;
                        case '\u0009': writer.WriteCommonConstant(ConstantString_Common.EscapeSequence_t); continue;
                        case '\u000A': writer.WriteCommonConstant(ConstantString_Common.EscapeSequence_n); continue;
                        case '\u000B': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_000B); continue;
                        case '\u000C': writer.WriteCommonConstant(ConstantString_Common.EscapeSequence_f); continue;
                        case '\u000D': writer.WriteCommonConstant(ConstantString_Common.EscapeSequence_r); continue;
                        case '\u000E': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_000E); continue;
                        case '\u000F': writer.Write000EscapeConstant(ConstantString_000Escape.EscapeSequence_000F); continue;
                        case '\u0010': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0010); continue;
                        case '\u0011': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0011); continue;
                        case '\u0012': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0012); continue;
                        case '\u0013': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0013); continue;
                        case '\u0014': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0014); continue;
                        case '\u0015': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0015); continue;
                        case '\u0016': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0016); continue;
                        case '\u0017': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0017); continue;
                        case '\u0018': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0018); continue;
                        case '\u0019': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_0019); continue;
                        case '\u001A': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001A); continue;
                        case '\u001B': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001B); continue;
                        case '\u001C': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001C); continue;
                        case '\u001D': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001D); continue;
                        case '\u001E': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001E); continue;
                        case '\u001F': writer.Write001EscapeConstant(ConstantString_001Escape.EscapeSequence_001F); continue;
                        default: writer.Write(c); continue;
                    }
                }
            }
        }
Ejemplo n.º 3
0
        static void _CustomRFC1123_ThunkWriter(ref ThunkWriter writer, DateTime dt)
        {
            writer.WriteFormattingConstant(ConstantString_Formatting.Quote);

            var dayOfWeek = (ConstantString_DaysOfWeek)(((byte)dt.DayOfWeek) * 3);
            writer.WriteDayOfWeek(dayOfWeek);
            writer.WriteFormattingConstant(ConstantString_Formatting.CommaSpace);

            {
                var day = DigitPairs[dt.Day];
                writer.Write(day.First);
                writer.Write(day.Second);
                writer.WriteFormattingConstant(ConstantString_Formatting.Space);
            }

            // compiles as a switch
            // not converted to a ConstantString_* enum because you can't pack these such that
            //   they fit in a cache line
            switch (dt.Month)
            {
                case 1: writer.Write("Jan "); break;
                case 2: writer.Write("Feb "); break;
                case 3: writer.Write("Mar "); break;
                case 4: writer.Write("Apr "); break;
                case 5: writer.Write("May "); break;
                case 6: writer.Write("Jun "); break;
                case 7: writer.Write("Jul "); break;
                case 8: writer.Write("Aug "); break;
                case 9: writer.Write("Sep "); break;
                case 10: writer.Write("Oct "); break;
                case 11: writer.Write("Nov "); break;
                case 12: writer.Write("Dec "); break;
            }

            {
                var year = dt.Year;
                var firstHalfYear = DigitPairs[year / 100];
                writer.Write(firstHalfYear.First);
                writer.Write(firstHalfYear.Second);

                var secondHalfYear = DigitPairs[year % 100];
                writer.Write(secondHalfYear.First);
                writer.Write(secondHalfYear.Second);
                writer.WriteFormattingConstant(ConstantString_Formatting.Space);
            }

            {
                var hour = DigitPairs[dt.Hour];
                writer.Write(hour.First);
                writer.Write(hour.Second);
                writer.WriteFormattingConstant(ConstantString_Formatting.Colon);
            }

            {
                var minute = DigitPairs[dt.Minute];
                writer.Write(minute.First);
                writer.Write(minute.Second);
                writer.WriteFormattingConstant(ConstantString_Formatting.Colon);
            }

            {
                var second = DigitPairs[dt.Second];
                writer.Write(second.First);
                writer.Write(second.Second);
            }

            writer.WriteValueConstant(ConstantString_Value.SpaceGMTQuote);
        }