Advertisement
T-D-K

Untitled

Feb 3rd, 2019
258
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 22.57 KB | None | 0 0
  1. // Decompiled with JetBrains decompiler
  2. // Type: CompilerLib.Token
  3. // Assembly: CompilerLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
  4. // MVID: 5C2BD8B5-BFF6-2D3A-A745-0383B5D82B5C
  5. // Assembly location: D:\JB\CompilerLib.dll
  6.  
  7. using Microsoft.FSharp.Core;
  8. using System;
  9. using System.Collections;
  10. using System.Diagnostics;
  11. using System.Runtime.CompilerServices;
  12. using System.Runtime.InteropServices;
  13.  
  14. namespace CompilerLib
  15. {
  16.   [DebuggerDisplay("{__DebugDisplay(),nq}")]
  17.   [CompilationMapping]
  18.   [Serializable]
  19.   [StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
  20.   public class Token : IEquatable<Token>, IStructuralEquatable, IComparable<Token>, IComparable, IStructuralComparable
  21.   {
  22.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  23.     [CompilerGenerated]
  24.     [DebuggerNonUserCode]
  25.     internal static readonly Token _unique_IncrementPtr = new Token(0);
  26.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  27.     [CompilerGenerated]
  28.     [DebuggerNonUserCode]
  29.     internal static readonly Token _unique_DecrementPtr = new Token(1);
  30.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  31.     [CompilerGenerated]
  32.     [DebuggerNonUserCode]
  33.     internal static readonly Token _unique_IncrementData = new Token(2);
  34.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  35.     [CompilerGenerated]
  36.     [DebuggerNonUserCode]
  37.     internal static readonly Token _unique_DecrementData = new Token(3);
  38.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  39.     [CompilerGenerated]
  40.     [DebuggerNonUserCode]
  41.     internal static readonly Token _unique_OutputData = new Token(4);
  42.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  43.     [CompilerGenerated]
  44.     [DebuggerNonUserCode]
  45.     internal static readonly Token _unique_InputData = new Token(5);
  46.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  47.     [CompilerGenerated]
  48.     [DebuggerNonUserCode]
  49.     internal static readonly Token _unique_LoopStart = new Token(6);
  50.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  51.     [CompilerGenerated]
  52.     [DebuggerNonUserCode]
  53.     internal static readonly Token _unique_LoopEnd = new Token(7);
  54.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  55.     [CompilerGenerated]
  56.     [DebuggerNonUserCode]
  57.     internal static readonly Token _unique_Unknown = new Token(8);
  58.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  59.     [CompilerGenerated]
  60.     [DebuggerNonUserCode]
  61.     internal static readonly Token _unique_ClearData = new Token(11);
  62.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  63.     [CompilerGenerated]
  64.     [DebuggerNonUserCode]
  65.     internal readonly int _tag;
  66.  
  67.     [CompilerGenerated]
  68.     [DebuggerNonUserCode]
  69.     internal Token(int _tag)
  70.     {
  71.       this._tag = _tag;
  72.     }
  73.  
  74.     [CompilationMapping]
  75.     public static Token get_IncrementPtr()
  76.     {
  77.       return Token._unique_IncrementPtr;
  78.     }
  79.  
  80.     [CompilerGenerated]
  81.     [DebuggerNonUserCode]
  82.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  83.     public static Token IncrementPtr
  84.     {
  85.       [CompilationMapping] get
  86.       {
  87.         return Token._unique_IncrementPtr;
  88.       }
  89.     }
  90.  
  91.     [DebuggerNonUserCode]
  92.     public bool get_IsIncrementPtr()
  93.     {
  94.       return this.get_Tag() == 0;
  95.     }
  96.  
  97.     [CompilerGenerated]
  98.     [DebuggerNonUserCode]
  99.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  100.     public bool IsIncrementPtr
  101.     {
  102.       [DebuggerNonUserCode] get
  103.       {
  104.         return this.get_Tag() == 0;
  105.       }
  106.     }
  107.  
  108.     [CompilerGenerated]
  109.     [DebuggerNonUserCode]
  110.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  111.     public static Token DecrementPtr
  112.     {
  113.       [CompilationMapping] get
  114.       {
  115.         return Token._unique_DecrementPtr;
  116.       }
  117.     }
  118.  
  119.     [CompilationMapping]
  120.     public static Token get_DecrementPtr()
  121.     {
  122.       return Token._unique_DecrementPtr;
  123.     }
  124.  
  125.     [DebuggerNonUserCode]
  126.     public bool get_IsDecrementPtr()
  127.     {
  128.       return this.get_Tag() == 1;
  129.     }
  130.  
  131.     [CompilerGenerated]
  132.     [DebuggerNonUserCode]
  133.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  134.     public bool IsDecrementPtr
  135.     {
  136.       [DebuggerNonUserCode] get
  137.       {
  138.         return this.get_Tag() == 1;
  139.       }
  140.     }
  141.  
  142.     [CompilationMapping]
  143.     public static Token get_IncrementData()
  144.     {
  145.       return Token._unique_IncrementData;
  146.     }
  147.  
  148.     [CompilerGenerated]
  149.     [DebuggerNonUserCode]
  150.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  151.     public static Token IncrementData
  152.     {
  153.       [CompilationMapping] get
  154.       {
  155.         return Token._unique_IncrementData;
  156.       }
  157.     }
  158.  
  159.     [CompilerGenerated]
  160.     [DebuggerNonUserCode]
  161.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  162.     public bool IsIncrementData
  163.     {
  164.       [DebuggerNonUserCode] get
  165.       {
  166.         return this.get_Tag() == 2;
  167.       }
  168.     }
  169.  
  170.     [DebuggerNonUserCode]
  171.     public bool get_IsIncrementData()
  172.     {
  173.       return this.get_Tag() == 2;
  174.     }
  175.  
  176.     [CompilerGenerated]
  177.     [DebuggerNonUserCode]
  178.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  179.     public static Token DecrementData
  180.     {
  181.       [CompilationMapping] get
  182.       {
  183.         return Token._unique_DecrementData;
  184.       }
  185.     }
  186.  
  187.     [CompilationMapping]
  188.     public static Token get_DecrementData()
  189.     {
  190.       return Token._unique_DecrementData;
  191.     }
  192.  
  193.     [DebuggerNonUserCode]
  194.     public bool get_IsDecrementData()
  195.     {
  196.       return this.get_Tag() == 3;
  197.     }
  198.  
  199.     [CompilerGenerated]
  200.     [DebuggerNonUserCode]
  201.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  202.     public bool IsDecrementData
  203.     {
  204.       [DebuggerNonUserCode] get
  205.       {
  206.         return this.get_Tag() == 3;
  207.       }
  208.     }
  209.  
  210.     [CompilerGenerated]
  211.     [DebuggerNonUserCode]
  212.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  213.     public static Token OutputData
  214.     {
  215.       [CompilationMapping] get
  216.       {
  217.         return Token._unique_OutputData;
  218.       }
  219.     }
  220.  
  221.     [CompilationMapping]
  222.     public static Token get_OutputData()
  223.     {
  224.       return Token._unique_OutputData;
  225.     }
  226.  
  227.     [DebuggerNonUserCode]
  228.     public bool get_IsOutputData()
  229.     {
  230.       return this.get_Tag() == 4;
  231.     }
  232.  
  233.     [CompilerGenerated]
  234.     [DebuggerNonUserCode]
  235.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  236.     public bool IsOutputData
  237.     {
  238.       [DebuggerNonUserCode] get
  239.       {
  240.         return this.get_Tag() == 4;
  241.       }
  242.     }
  243.  
  244.     [CompilerGenerated]
  245.     [DebuggerNonUserCode]
  246.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  247.     public static Token InputData
  248.     {
  249.       [CompilationMapping] get
  250.       {
  251.         return Token._unique_InputData;
  252.       }
  253.     }
  254.  
  255.     [CompilationMapping]
  256.     public static Token get_InputData()
  257.     {
  258.       return Token._unique_InputData;
  259.     }
  260.  
  261.     [CompilerGenerated]
  262.     [DebuggerNonUserCode]
  263.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  264.     public bool IsInputData
  265.     {
  266.       [DebuggerNonUserCode] get
  267.       {
  268.         return this.get_Tag() == 5;
  269.       }
  270.     }
  271.  
  272.     [DebuggerNonUserCode]
  273.     public bool get_IsInputData()
  274.     {
  275.       return this.get_Tag() == 5;
  276.     }
  277.  
  278.     [CompilationMapping]
  279.     public static Token get_LoopStart()
  280.     {
  281.       return Token._unique_LoopStart;
  282.     }
  283.  
  284.     [CompilerGenerated]
  285.     [DebuggerNonUserCode]
  286.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  287.     public static Token LoopStart
  288.     {
  289.       [CompilationMapping] get
  290.       {
  291.         return Token._unique_LoopStart;
  292.       }
  293.     }
  294.  
  295.     [DebuggerNonUserCode]
  296.     public bool get_IsLoopStart()
  297.     {
  298.       return this.get_Tag() == 6;
  299.     }
  300.  
  301.     [CompilerGenerated]
  302.     [DebuggerNonUserCode]
  303.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  304.     public bool IsLoopStart
  305.     {
  306.       [DebuggerNonUserCode] get
  307.       {
  308.         return this.get_Tag() == 6;
  309.       }
  310.     }
  311.  
  312.     [CompilationMapping]
  313.     public static Token get_LoopEnd()
  314.     {
  315.       return Token._unique_LoopEnd;
  316.     }
  317.  
  318.     [CompilerGenerated]
  319.     [DebuggerNonUserCode]
  320.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  321.     public static Token LoopEnd
  322.     {
  323.       [CompilationMapping] get
  324.       {
  325.         return Token._unique_LoopEnd;
  326.       }
  327.     }
  328.  
  329.     [DebuggerNonUserCode]
  330.     public bool get_IsLoopEnd()
  331.     {
  332.       return this.get_Tag() == 7;
  333.     }
  334.  
  335.     [CompilerGenerated]
  336.     [DebuggerNonUserCode]
  337.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  338.     public bool IsLoopEnd
  339.     {
  340.       [DebuggerNonUserCode] get
  341.       {
  342.         return this.get_Tag() == 7;
  343.       }
  344.     }
  345.  
  346.     [CompilerGenerated]
  347.     [DebuggerNonUserCode]
  348.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  349.     public static Token Unknown
  350.     {
  351.       [CompilationMapping] get
  352.       {
  353.         return Token._unique_Unknown;
  354.       }
  355.     }
  356.  
  357.     [CompilationMapping]
  358.     public static Token get_Unknown()
  359.     {
  360.       return Token._unique_Unknown;
  361.     }
  362.  
  363.     [CompilerGenerated]
  364.     [DebuggerNonUserCode]
  365.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  366.     public bool IsUnknown
  367.     {
  368.       [DebuggerNonUserCode] get
  369.       {
  370.         return this.get_Tag() == 8;
  371.       }
  372.     }
  373.  
  374.     [DebuggerNonUserCode]
  375.     public bool get_IsUnknown()
  376.     {
  377.       return this.get_Tag() == 8;
  378.     }
  379.  
  380.     [CompilationMapping]
  381.     public static Token NewMovePtrDelta(int _delta)
  382.     {
  383.       return (Token) new Token.MovePtrDelta(_delta);
  384.     }
  385.  
  386.     [DebuggerNonUserCode]
  387.     public bool get_IsMovePtrDelta()
  388.     {
  389.       return this.get_Tag() == 9;
  390.     }
  391.  
  392.     [CompilerGenerated]
  393.     [DebuggerNonUserCode]
  394.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  395.     public bool IsMovePtrDelta
  396.     {
  397.       [DebuggerNonUserCode] get
  398.       {
  399.         return this.get_Tag() == 9;
  400.       }
  401.     }
  402.  
  403.     [CompilationMapping]
  404.     public static Token NewSetDataDelta(int _delta)
  405.     {
  406.       return (Token) new Token.SetDataDelta(_delta);
  407.     }
  408.  
  409.     [CompilerGenerated]
  410.     [DebuggerNonUserCode]
  411.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  412.     public bool IsSetDataDelta
  413.     {
  414.       [DebuggerNonUserCode] get
  415.       {
  416.         return this.get_Tag() == 10;
  417.       }
  418.     }
  419.  
  420.     [DebuggerNonUserCode]
  421.     public bool get_IsSetDataDelta()
  422.     {
  423.       return this.get_Tag() == 10;
  424.     }
  425.  
  426.     [CompilerGenerated]
  427.     [DebuggerNonUserCode]
  428.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  429.     public static Token ClearData
  430.     {
  431.       [CompilationMapping] get
  432.       {
  433.         return Token._unique_ClearData;
  434.       }
  435.     }
  436.  
  437.     [CompilationMapping]
  438.     public static Token get_ClearData()
  439.     {
  440.       return Token._unique_ClearData;
  441.     }
  442.  
  443.     [CompilerGenerated]
  444.     [DebuggerNonUserCode]
  445.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  446.     public bool IsClearData
  447.     {
  448.       [DebuggerNonUserCode] get
  449.       {
  450.         return this.get_Tag() == 11;
  451.       }
  452.     }
  453.  
  454.     [DebuggerNonUserCode]
  455.     public bool get_IsClearData()
  456.     {
  457.       return this.get_Tag() == 11;
  458.     }
  459.  
  460.     [DebuggerNonUserCode]
  461.     public int get_Tag()
  462.     {
  463.       return this._tag;
  464.     }
  465.  
  466.     [CompilerGenerated]
  467.     [DebuggerNonUserCode]
  468.     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  469.     public int Tag
  470.     {
  471.       [DebuggerNonUserCode] get
  472.       {
  473.         return this._tag;
  474.       }
  475.     }
  476.  
  477.     [CompilerGenerated]
  478.     [DebuggerNonUserCode]
  479.     [SpecialName]
  480.     internal object __DebugDisplay()
  481.     {
  482.       return (object) ((FSharpFunc<Token, string>) ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<Token, string>>((PrintfFormat<M0, Unit, string, string>) new PrintfFormat<FSharpFunc<Token, string>, Unit, string, string, string>("%+0.8A"))).Invoke(this);
  483.     }
  484.  
  485.     [CompilerGenerated]
  486.     public override string ToString()
  487.     {
  488.       return ((FSharpFunc<Token, string>) ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<Token, string>>((PrintfFormat<M0, Unit, string, string>) new PrintfFormat<FSharpFunc<Token, string>, Unit, string, string, Token>("%+A"))).Invoke(this);
  489.     }
  490.  
  491.     [CompilerGenerated]
  492.     public virtual int CompareTo(Token obj)
  493.     {
  494.       if (this != null)
  495.       {
  496.         if (obj == null)
  497.           return 1;
  498.         int tag1 = this._tag;
  499.         int tag2 = obj._tag;
  500.         if (tag1 != tag2)
  501.           return tag1 - tag2;
  502.         switch (this.get_Tag())
  503.         {
  504.           case 9:
  505.             Token.MovePtrDelta movePtrDelta1 = (Token.MovePtrDelta) this;
  506.             Token.MovePtrDelta movePtrDelta2 = (Token.MovePtrDelta) obj;
  507.             LanguagePrimitives.get_GenericComparer();
  508.             int delta1 = movePtrDelta1._delta;
  509.             int delta2 = movePtrDelta2._delta;
  510.             if (delta1 < delta2)
  511.               return -1;
  512.             return delta1 > delta2 ? 1 : 0;
  513.           case 10:
  514.             Token.SetDataDelta setDataDelta1 = (Token.SetDataDelta) this;
  515.             Token.SetDataDelta setDataDelta2 = (Token.SetDataDelta) obj;
  516.             LanguagePrimitives.get_GenericComparer();
  517.             int delta3 = setDataDelta1._delta;
  518.             int delta4 = setDataDelta2._delta;
  519.             if (delta3 < delta4)
  520.               return -1;
  521.             return delta3 > delta4 ? 1 : 0;
  522.           default:
  523.             return 0;
  524.         }
  525.       }
  526.       else
  527.         return obj != null ? -1 : 0;
  528.     }
  529.  
  530.     [CompilerGenerated]
  531.     public virtual int CompareTo(object obj)
  532.     {
  533.       return this.CompareTo((Token) obj);
  534.     }
  535.  
  536.     [CompilerGenerated]
  537.     public virtual int CompareTo(object obj, IComparer comp)
  538.     {
  539.       Token token = (Token) obj;
  540.       if (this != null)
  541.       {
  542.         if ((Token) obj == null)
  543.           return 1;
  544.         int tag1 = this._tag;
  545.         int tag2 = token._tag;
  546.         if (tag1 != tag2)
  547.           return tag1 - tag2;
  548.         switch (this.get_Tag())
  549.         {
  550.           case 9:
  551.             Token.MovePtrDelta movePtrDelta1 = (Token.MovePtrDelta) this;
  552.             Token.MovePtrDelta movePtrDelta2 = (Token.MovePtrDelta) token;
  553.             int delta1 = movePtrDelta1._delta;
  554.             int delta2 = movePtrDelta2._delta;
  555.             if (delta1 < delta2)
  556.               return -1;
  557.             return delta1 > delta2 ? 1 : 0;
  558.           case 10:
  559.             Token.SetDataDelta setDataDelta1 = (Token.SetDataDelta) this;
  560.             Token.SetDataDelta setDataDelta2 = (Token.SetDataDelta) token;
  561.             int delta3 = setDataDelta1._delta;
  562.             int delta4 = setDataDelta2._delta;
  563.             if (delta3 < delta4)
  564.               return -1;
  565.             return delta3 > delta4 ? 1 : 0;
  566.           default:
  567.             return 0;
  568.         }
  569.       }
  570.       else
  571.         return (Token) obj != null ? -1 : 0;
  572.     }
  573.  
  574.     [CompilerGenerated]
  575.     public virtual int GetHashCode(IEqualityComparer comp)
  576.     {
  577.       if (this == null)
  578.         return 0;
  579.       switch (this.get_Tag())
  580.       {
  581.         case 9:
  582.           Token.MovePtrDelta movePtrDelta = (Token.MovePtrDelta) this;
  583.           int num1 = 9;
  584.           return movePtrDelta._delta + ((num1 << 6) + (num1 >> 2)) - 1640531527;
  585.         case 10:
  586.           Token.SetDataDelta setDataDelta = (Token.SetDataDelta) this;
  587.           int num2 = 10;
  588.           return setDataDelta._delta + ((num2 << 6) + (num2 >> 2)) - 1640531527;
  589.         default:
  590.           return this._tag;
  591.       }
  592.     }
  593.  
  594.     [CompilerGenerated]
  595.     public override sealed int GetHashCode()
  596.     {
  597.       return this.GetHashCode(LanguagePrimitives.get_GenericEqualityComparer());
  598.     }
  599.  
  600.     [CompilerGenerated]
  601.     public virtual bool Equals(object obj, IEqualityComparer comp)
  602.     {
  603.       if (this == null)
  604.         return obj == null;
  605.       Token token1 = obj as Token;
  606.       if (token1 == null)
  607.         return false;
  608.       Token token2 = token1;
  609.       if (this._tag != token2._tag)
  610.         return false;
  611.       switch (this.get_Tag())
  612.       {
  613.         case 9:
  614.           return ((Token.MovePtrDelta) this)._delta == ((Token.MovePtrDelta) token2)._delta;
  615.         case 10:
  616.           return ((Token.SetDataDelta) this)._delta == ((Token.SetDataDelta) token2)._delta;
  617.         default:
  618.           return true;
  619.       }
  620.     }
  621.  
  622.     [CompilerGenerated]
  623.     public virtual bool Equals(Token obj)
  624.     {
  625.       if (this == null)
  626.         return obj == null;
  627.       if (obj == null || this._tag != obj._tag)
  628.         return false;
  629.       switch (this.get_Tag())
  630.       {
  631.         case 9:
  632.           return ((Token.MovePtrDelta) this)._delta == ((Token.MovePtrDelta) obj)._delta;
  633.         case 10:
  634.           return ((Token.SetDataDelta) this)._delta == ((Token.SetDataDelta) obj)._delta;
  635.         default:
  636.           return true;
  637.       }
  638.     }
  639.  
  640.     [CompilerGenerated]
  641.     public override sealed bool Equals(object obj)
  642.     {
  643.       Token token = obj as Token;
  644.       if (token != null)
  645.         return this.Equals(token);
  646.       return false;
  647.     }
  648.  
  649.     public static class Tags
  650.     {
  651.       public const int IncrementPtr = 0;
  652.       public const int DecrementPtr = 1;
  653.       public const int IncrementData = 2;
  654.       public const int DecrementData = 3;
  655.       public const int OutputData = 4;
  656.       public const int InputData = 5;
  657.       public const int LoopStart = 6;
  658.       public const int LoopEnd = 7;
  659.       public const int Unknown = 8;
  660.       public const int MovePtrDelta = 9;
  661.       public const int SetDataDelta = 10;
  662.       public const int ClearData = 11;
  663.     }
  664.  
  665.     [DebuggerTypeProxy(typeof (Token.MovePtrDelta\u0040DebugTypeProxy))]
  666.     [DebuggerDisplay("{__DebugDisplay(),nq}")]
  667.     [Serializable]
  668.     [SpecialName]
  669.     public class MovePtrDelta : Token
  670.     {
  671.       [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  672.       [CompilerGenerated]
  673.       [DebuggerNonUserCode]
  674.       internal readonly int _delta;
  675.  
  676.       [CompilerGenerated]
  677.       [DebuggerNonUserCode]
  678.       internal MovePtrDelta(int _delta)
  679.         : base(9)
  680.       {
  681.         this._delta = _delta;
  682.       }
  683.  
  684.       [DebuggerNonUserCode]
  685.       public int get_delta()
  686.       {
  687.         return this._delta;
  688.       }
  689.  
  690.       [CompilationMapping]
  691.       [CompilerGenerated]
  692.       [DebuggerNonUserCode]
  693.       public int delta
  694.       {
  695.         [DebuggerNonUserCode] get
  696.         {
  697.           return this._delta;
  698.         }
  699.       }
  700.     }
  701.  
  702.     [DebuggerTypeProxy(typeof (Token.SetDataDelta\u0040DebugTypeProxy))]
  703.     [DebuggerDisplay("{__DebugDisplay(),nq}")]
  704.     [Serializable]
  705.     [SpecialName]
  706.     public class SetDataDelta : Token
  707.     {
  708.       [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  709.       [CompilerGenerated]
  710.       [DebuggerNonUserCode]
  711.       internal readonly int _delta;
  712.  
  713.       [CompilerGenerated]
  714.       [DebuggerNonUserCode]
  715.       internal SetDataDelta(int _delta)
  716.         : base(10)
  717.       {
  718.         this._delta = _delta;
  719.       }
  720.  
  721.       [DebuggerNonUserCode]
  722.       public int get_delta()
  723.       {
  724.         return this._delta;
  725.       }
  726.  
  727.       [CompilationMapping]
  728.       [CompilerGenerated]
  729.       [DebuggerNonUserCode]
  730.       public int delta
  731.       {
  732.         [DebuggerNonUserCode] get
  733.         {
  734.           return this._delta;
  735.         }
  736.       }
  737.     }
  738.  
  739.     [SpecialName]
  740.     internal class MovePtrDelta\u0040DebugTypeProxy
  741.     {
  742.       [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  743.       [CompilerGenerated]
  744.       [DebuggerNonUserCode]
  745.       internal Token.MovePtrDelta _obj;
  746.  
  747.       [CompilerGenerated]
  748.       [DebuggerNonUserCode]
  749.       public MovePtrDelta\u0040DebugTypeProxy(Token.MovePtrDelta obj)
  750.       {
  751.         this._obj = obj;
  752.       }
  753.  
  754.       [DebuggerNonUserCode]
  755.       public int get_delta()
  756.       {
  757.         return this._obj._delta;
  758.       }
  759.  
  760.       [CompilationMapping]
  761.       [CompilerGenerated]
  762.       [DebuggerNonUserCode]
  763.       public int delta
  764.       {
  765.         [DebuggerNonUserCode] get
  766.         {
  767.           return this._obj._delta;
  768.         }
  769.       }
  770.     }
  771.  
  772.     [SpecialName]
  773.     internal class SetDataDelta\u0040DebugTypeProxy
  774.     {
  775.       [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  776.       [CompilerGenerated]
  777.       [DebuggerNonUserCode]
  778.       internal Token.SetDataDelta _obj;
  779.  
  780.       [CompilerGenerated]
  781.       [DebuggerNonUserCode]
  782.       public SetDataDelta\u0040DebugTypeProxy(Token.SetDataDelta obj)
  783.       {
  784.         this._obj = obj;
  785.       }
  786.  
  787.       [DebuggerNonUserCode]
  788.       public int get_delta()
  789.       {
  790.         return this._obj._delta;
  791.       }
  792.  
  793.       [CompilationMapping]
  794.       [CompilerGenerated]
  795.       [DebuggerNonUserCode]
  796.       public int delta
  797.       {
  798.         [DebuggerNonUserCode] get
  799.         {
  800.           return this._obj._delta;
  801.         }
  802.       }
  803.     }
  804.   }
  805. }
  806.  
  807.  
  808. // Decompiled with JetBrains decompiler
  809. // Type: CompilerLib.Tokens
  810. // Assembly: CompilerLib, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
  811. // MVID: 5C2BD8B5-BFF6-2D3A-A745-0383B5D82B5C
  812. // Assembly location: D:\JB\CompilerLib.dll
  813.  
  814. using Microsoft.FSharp.Collections;
  815. using Microsoft.FSharp.Core;
  816. using System;
  817. using System.Diagnostics;
  818. using System.Runtime.CompilerServices;
  819.  
  820. namespace CompilerLib
  821. {
  822.   [CompilationMapping]
  823.   public static class Tokens
  824.   {
  825.     public static FSharpList<Token> tokenize(string code)
  826.     {
  827.       return (FSharpList<Token>) ListModule.Filter<Token>((FSharpFunc<M0, bool>) new Tokens.tokenize\u004029(Token.get_Unknown()), (FSharpList<M0>) ListModule.Map<char, Token>((FSharpFunc<M0, M1>) new Tokens.tokenize\u004018\u002D1(), ArrayModule.ToList<char>((M0[]) code.ToCharArray())));
  828.     }
  829.  
  830.     [Serializable]
  831.     internal sealed class tokenize\u004029 : FSharpFunc<Token, bool>
  832.     {
  833.       [DebuggerBrowsable(DebuggerBrowsableState.Never)]
  834.       [CompilerGenerated]
  835.       [DebuggerNonUserCode]
  836.       public Token x;
  837.  
  838.       [CompilerGenerated]
  839.       [DebuggerNonUserCode]
  840.       internal tokenize\u004029(Token x)
  841.       {
  842.         this.\u002Ector();
  843.         this.x = x;
  844.       }
  845.  
  846.       public virtual bool Invoke(Token y)
  847.       {
  848.         return !this.x.Equals((object) y, LanguagePrimitives.get_GenericEqualityComparer());
  849.       }
  850.     }
  851.  
  852.     [Serializable]
  853.     internal sealed class tokenize\u004018\u002D1 : FSharpFunc<char, Token>
  854.     {
  855.       [CompilerGenerated]
  856.       [DebuggerNonUserCode]
  857.       internal tokenize\u004018\u002D1()
  858.       {
  859.         base.\u002Ector();
  860.       }
  861.  
  862.       public virtual Token Invoke(char x)
  863.       {
  864.         switch (x)
  865.         {
  866.           case '+':
  867.             return Token.get_IncrementData();
  868.           case ',':
  869.             return Token.get_InputData();
  870.           case '-':
  871.             return Token.get_DecrementData();
  872.           case '.':
  873.             return Token.get_OutputData();
  874.           case '<':
  875.             return Token.get_DecrementPtr();
  876.           case '>':
  877.             return Token.get_IncrementPtr();
  878.           case '[':
  879.             return Token.get_LoopStart();
  880.           case ']':
  881.             return Token.get_LoopEnd();
  882.           default:
  883.             return Token.get_Unknown();
  884.         }
  885.       }
  886.     }
  887.   }
  888. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement