using System;
using System.Collections;

namespace System.Text.RegularExpressions
{
	// Token: 0x020002C8 RID: 712
	internal class PatternCompiler : ICompiler
	{
		// Token: 0x060019D9 RID: 6617 RVA: 0x0005C534 File Offset: 0x0005A734
		public PatternCompiler()
		{
			this.pgm = new ArrayList();
		}

		// Token: 0x060019DA RID: 6618 RVA: 0x0005C548 File Offset: 0x0005A748
		public static ushort EncodeOp(OpCode op, OpFlags flags)
		{
			return (ushort)(op | (OpCode)(flags & (OpFlags)65280));
		}

		// Token: 0x060019DB RID: 6619 RVA: 0x0005C554 File Offset: 0x0005A754
		public static void DecodeOp(ushort word, out OpCode op, out OpFlags flags)
		{
			op = (OpCode)(word & 255);
			flags = (OpFlags)(word & 65280);
		}

		// Token: 0x060019DC RID: 6620 RVA: 0x0005C56C File Offset: 0x0005A76C
		public void Reset()
		{
			this.pgm.Clear();
		}

		// Token: 0x060019DD RID: 6621 RVA: 0x0005C57C File Offset: 0x0005A77C
		public IMachineFactory GetMachineFactory()
		{
			ushort[] array = new ushort[this.pgm.Count];
			this.pgm.CopyTo(array);
			return new InterpreterFactory(array);
		}

		// Token: 0x060019DE RID: 6622 RVA: 0x0005C5AC File Offset: 0x0005A7AC
		public void EmitFalse()
		{
			this.Emit(OpCode.False);
		}

		// Token: 0x060019DF RID: 6623 RVA: 0x0005C5B8 File Offset: 0x0005A7B8
		public void EmitTrue()
		{
			this.Emit(OpCode.True);
		}

		// Token: 0x060019E0 RID: 6624 RVA: 0x0005C5C4 File Offset: 0x0005A7C4
		private void EmitCount(int count)
		{
			this.Emit((ushort)(count & 65535));
			this.Emit((ushort)((uint)count >> 16));
		}

		// Token: 0x060019E1 RID: 6625 RVA: 0x0005C5EC File Offset: 0x0005A7EC
		public void EmitCharacter(char c, bool negate, bool ignore, bool reverse)
		{
			this.Emit(OpCode.Character, PatternCompiler.MakeFlags(negate, ignore, reverse, false));
			if (ignore)
			{
				c = char.ToLower(c);
			}
			this.Emit((ushort)c);
		}

		// Token: 0x060019E2 RID: 6626 RVA: 0x0005C620 File Offset: 0x0005A820
		public void EmitCategory(Category cat, bool negate, bool reverse)
		{
			this.Emit(OpCode.Category, PatternCompiler.MakeFlags(negate, false, reverse, false));
			this.Emit((ushort)cat);
		}

		// Token: 0x060019E3 RID: 6627 RVA: 0x0005C63C File Offset: 0x0005A83C
		public void EmitNotCategory(Category cat, bool negate, bool reverse)
		{
			this.Emit(OpCode.NotCategory, PatternCompiler.MakeFlags(negate, false, reverse, false));
			this.Emit((ushort)cat);
		}

		// Token: 0x060019E4 RID: 6628 RVA: 0x0005C658 File Offset: 0x0005A858
		public void EmitRange(char lo, char hi, bool negate, bool ignore, bool reverse)
		{
			this.Emit(OpCode.Range, PatternCompiler.MakeFlags(negate, ignore, reverse, false));
			this.Emit((ushort)lo);
			this.Emit((ushort)hi);
		}

		// Token: 0x060019E5 RID: 6629 RVA: 0x0005C688 File Offset: 0x0005A888
		public void EmitSet(char lo, BitArray set, bool negate, bool ignore, bool reverse)
		{
			this.Emit(OpCode.Set, PatternCompiler.MakeFlags(negate, ignore, reverse, false));
			this.Emit((ushort)lo);
			int num = set.Length + 15 >> 4;
			this.Emit((ushort)num);
			int num2 = 0;
			while (num-- != 0)
			{
				ushort num3 = 0;
				for (int i = 0; i < 16; i++)
				{
					if (num2 >= set.Length)
					{
						break;
					}
					if (set[num2++])
					{
						num3 |= (ushort)(1 << i);
					}
				}
				this.Emit(num3);
			}
		}

		// Token: 0x060019E6 RID: 6630 RVA: 0x0005C71C File Offset: 0x0005A91C
		public void EmitString(string str, bool ignore, bool reverse)
		{
			this.Emit(OpCode.String, PatternCompiler.MakeFlags(false, ignore, reverse, false));
			int length = str.Length;
			this.Emit((ushort)length);
			if (ignore)
			{
				str = str.ToLower();
			}
			for (int i = 0; i < length; i++)
			{
				this.Emit((ushort)str[i]);
			}
		}

		// Token: 0x060019E7 RID: 6631 RVA: 0x0005C778 File Offset: 0x0005A978
		public void EmitPosition(Position pos)
		{
			this.Emit(OpCode.Position, OpFlags.None);
			this.Emit((ushort)pos);
		}

		// Token: 0x060019E8 RID: 6632 RVA: 0x0005C78C File Offset: 0x0005A98C
		public void EmitOpen(int gid)
		{
			this.Emit(OpCode.Open);
			this.Emit((ushort)gid);
		}

		// Token: 0x060019E9 RID: 6633 RVA: 0x0005C7A0 File Offset: 0x0005A9A0
		public void EmitClose(int gid)
		{
			this.Emit(OpCode.Close);
			this.Emit((ushort)gid);
		}

		// Token: 0x060019EA RID: 6634 RVA: 0x0005C7B4 File Offset: 0x0005A9B4
		public void EmitBalanceStart(int gid, int balance, bool capture, LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.BalanceStart);
			this.Emit((ushort)gid);
			this.Emit((ushort)balance);
			this.Emit((!capture) ? 0 : 1);
			this.EmitLink(tail);
		}

		// Token: 0x060019EB RID: 6635 RVA: 0x0005C800 File Offset: 0x0005AA00
		public void EmitBalance()
		{
			this.Emit(OpCode.Balance);
		}

		// Token: 0x060019EC RID: 6636 RVA: 0x0005C80C File Offset: 0x0005AA0C
		public void EmitReference(int gid, bool ignore, bool reverse)
		{
			this.Emit(OpCode.Reference, PatternCompiler.MakeFlags(false, ignore, reverse, false));
			this.Emit((ushort)gid);
		}

		// Token: 0x060019ED RID: 6637 RVA: 0x0005C828 File Offset: 0x0005AA28
		public void EmitIfDefined(int gid, LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.IfDefined);
			this.EmitLink(tail);
			this.Emit((ushort)gid);
		}

		// Token: 0x060019EE RID: 6638 RVA: 0x0005C854 File Offset: 0x0005AA54
		public void EmitSub(LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.Sub);
			this.EmitLink(tail);
		}

		// Token: 0x060019EF RID: 6639 RVA: 0x0005C86C File Offset: 0x0005AA6C
		public void EmitTest(LinkRef yes, LinkRef tail)
		{
			this.BeginLink(yes);
			this.BeginLink(tail);
			this.Emit(OpCode.Test);
			this.EmitLink(yes);
			this.EmitLink(tail);
		}

		// Token: 0x060019F0 RID: 6640 RVA: 0x0005C8A0 File Offset: 0x0005AAA0
		public void EmitBranch(LinkRef next)
		{
			this.BeginLink(next);
			this.Emit(OpCode.Branch, OpFlags.None);
			this.EmitLink(next);
		}

		// Token: 0x060019F1 RID: 6641 RVA: 0x0005C8BC File Offset: 0x0005AABC
		public void EmitJump(LinkRef target)
		{
			this.BeginLink(target);
			this.Emit(OpCode.Jump, OpFlags.None);
			this.EmitLink(target);
		}

		// Token: 0x060019F2 RID: 6642 RVA: 0x0005C8D8 File Offset: 0x0005AAD8
		public void EmitRepeat(int min, int max, bool lazy, LinkRef until)
		{
			this.BeginLink(until);
			this.Emit(OpCode.Repeat, PatternCompiler.MakeFlags(false, false, false, lazy));
			this.EmitLink(until);
			this.EmitCount(min);
			this.EmitCount(max);
		}

		// Token: 0x060019F3 RID: 6643 RVA: 0x0005C914 File Offset: 0x0005AB14
		public void EmitUntil(LinkRef repeat)
		{
			this.ResolveLink(repeat);
			this.Emit(OpCode.Until);
		}

		// Token: 0x060019F4 RID: 6644 RVA: 0x0005C928 File Offset: 0x0005AB28
		public void EmitFastRepeat(int min, int max, bool lazy, LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.FastRepeat, PatternCompiler.MakeFlags(false, false, false, lazy));
			this.EmitLink(tail);
			this.EmitCount(min);
			this.EmitCount(max);
		}

		// Token: 0x060019F5 RID: 6645 RVA: 0x0005C964 File Offset: 0x0005AB64
		public void EmitIn(LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.In);
			this.EmitLink(tail);
		}

		// Token: 0x060019F6 RID: 6646 RVA: 0x0005C97C File Offset: 0x0005AB7C
		public void EmitAnchor(bool reverse, int offset, LinkRef tail)
		{
			this.BeginLink(tail);
			this.Emit(OpCode.Anchor, PatternCompiler.MakeFlags(false, false, reverse, false));
			this.EmitLink(tail);
			this.Emit((ushort)offset);
		}

		// Token: 0x060019F7 RID: 6647 RVA: 0x0005C9B0 File Offset: 0x0005ABB0
		public void EmitInfo(int count, int min, int max)
		{
			this.Emit(OpCode.Info);
			this.EmitCount(count);
			this.EmitCount(min);
			this.EmitCount(max);
		}

		// Token: 0x060019F8 RID: 6648 RVA: 0x0005C9DC File Offset: 0x0005ABDC
		public LinkRef NewLink()
		{
			return new PatternCompiler.PatternLinkStack();
		}

		// Token: 0x060019F9 RID: 6649 RVA: 0x0005C9E4 File Offset: 0x0005ABE4
		public void ResolveLink(LinkRef lref)
		{
			PatternCompiler.PatternLinkStack patternLinkStack = (PatternCompiler.PatternLinkStack)lref;
			while (patternLinkStack.Pop())
			{
				this.pgm[patternLinkStack.OffsetAddress] = (ushort)patternLinkStack.GetOffset(this.CurrentAddress);
			}
		}

		// Token: 0x060019FA RID: 6650 RVA: 0x0005CA2C File Offset: 0x0005AC2C
		public void EmitBranchEnd()
		{
		}

		// Token: 0x060019FB RID: 6651 RVA: 0x0005CA30 File Offset: 0x0005AC30
		public void EmitAlternationEnd()
		{
		}

		// Token: 0x060019FC RID: 6652 RVA: 0x0005CA34 File Offset: 0x0005AC34
		private static OpFlags MakeFlags(bool negate, bool ignore, bool reverse, bool lazy)
		{
			OpFlags opFlags = OpFlags.None;
			if (negate)
			{
				opFlags |= OpFlags.Negate;
			}
			if (ignore)
			{
				opFlags |= OpFlags.IgnoreCase;
			}
			if (reverse)
			{
				opFlags |= OpFlags.RightToLeft;
			}
			if (lazy)
			{
				opFlags |= OpFlags.Lazy;
			}
			return opFlags;
		}

		// Token: 0x060019FD RID: 6653 RVA: 0x0005CA80 File Offset: 0x0005AC80
		private void Emit(OpCode op)
		{
			this.Emit(op, OpFlags.None);
		}

		// Token: 0x060019FE RID: 6654 RVA: 0x0005CA8C File Offset: 0x0005AC8C
		private void Emit(OpCode op, OpFlags flags)
		{
			this.Emit(PatternCompiler.EncodeOp(op, flags));
		}

		// Token: 0x060019FF RID: 6655 RVA: 0x0005CA9C File Offset: 0x0005AC9C
		private void Emit(ushort word)
		{
			this.pgm.Add(word);
		}

		// Token: 0x17000805 RID: 2053
		// (get) Token: 0x06001A00 RID: 6656 RVA: 0x0005CAB0 File Offset: 0x0005ACB0
		private int CurrentAddress
		{
			get
			{
				return this.pgm.Count;
			}
		}

		// Token: 0x06001A01 RID: 6657 RVA: 0x0005CAC0 File Offset: 0x0005ACC0
		private void BeginLink(LinkRef lref)
		{
			PatternCompiler.PatternLinkStack patternLinkStack = (PatternCompiler.PatternLinkStack)lref;
			patternLinkStack.BaseAddress = this.CurrentAddress;
		}

		// Token: 0x06001A02 RID: 6658 RVA: 0x0005CAE0 File Offset: 0x0005ACE0
		private void EmitLink(LinkRef lref)
		{
			PatternCompiler.PatternLinkStack patternLinkStack = (PatternCompiler.PatternLinkStack)lref;
			patternLinkStack.OffsetAddress = this.CurrentAddress;
			this.Emit(0);
			patternLinkStack.Push();
		}

		// Token: 0x04001574 RID: 5492
		private ArrayList pgm;

		// Token: 0x020002C9 RID: 713
		private class PatternLinkStack : LinkStack
		{
			// Token: 0x17000806 RID: 2054
			// (set) Token: 0x06001A04 RID: 6660 RVA: 0x0005CB18 File Offset: 0x0005AD18
			public int BaseAddress
			{
				set
				{
					this.link.base_addr = value;
				}
			}

			// Token: 0x17000807 RID: 2055
			// (get) Token: 0x06001A05 RID: 6661 RVA: 0x0005CB28 File Offset: 0x0005AD28
			// (set) Token: 0x06001A06 RID: 6662 RVA: 0x0005CB38 File Offset: 0x0005AD38
			public int OffsetAddress
			{
				get
				{
					return this.link.offset_addr;
				}
				set
				{
					this.link.offset_addr = value;
				}
			}

			// Token: 0x06001A07 RID: 6663 RVA: 0x0005CB48 File Offset: 0x0005AD48
			public int GetOffset(int target_addr)
			{
				return target_addr - this.link.base_addr;
			}

			// Token: 0x06001A08 RID: 6664 RVA: 0x0005CB58 File Offset: 0x0005AD58
			protected override object GetCurrent()
			{
				return this.link;
			}

			// Token: 0x06001A09 RID: 6665 RVA: 0x0005CB68 File Offset: 0x0005AD68
			protected override void SetCurrent(object l)
			{
				this.link = (PatternCompiler.PatternLinkStack.Link)l;
			}

			// Token: 0x04001575 RID: 5493
			private PatternCompiler.PatternLinkStack.Link link;

			// Token: 0x020002CA RID: 714
			private struct Link
			{
				// Token: 0x04001576 RID: 5494
				public int base_addr;

				// Token: 0x04001577 RID: 5495
				public int offset_addr;
			}
		}
	}
}