public static void DumpMem(object b, DumpState D)
        {
#if XBOX || SILVERLIGHT
			// todo: implement this - mjf
			Debug.Assert(false);
#else
            //Console.WriteLine(b.GetType().ToString() + ":::" + b.ToString());
            //uint size = (uint)Marshal.SizeOf(b);
            //D.status = D.writer(D.L, new CharPtr(b.ToString()), size, D.data);
            
            ///*
            int size = Marshal.SizeOf(b);
            IntPtr ptr = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(b, ptr, false);
            byte[] bytes = new byte[size];
            Marshal.Copy(ptr, bytes, 0, size);
            char[] ch = new char[bytes.Length];
            for (int i = 0; i < bytes.Length; i++)
                ch[i] = (char)bytes[i];
            CharPtr str = ch;
            DumpBlock(str, (uint)str.chars.Length, D);
            Marshal.Release(ptr);
            // */
#endif
        }

 public static void DumpMem(object b, int n, DumpState D)
 {
     Array array = b as Array;
     Debug.Assert(array.Length == n);
     for (int i = 0; i < n; i++)
         DumpMem(array.GetValue(i), D);
 }

 public override void Write(object o, HtmlWriter tag, DumpState state, RefDictionary refDict)
 {
     var val =  o.ToString();
     tag.Tag("kbd", t =>
     {
         t.NewLineAfterSTag = false;
         t.WriteString(val);
     });
 }

 private static void DumpBlock(CharPtr b, uint size, DumpState D)
 {
     if (D.status==0)
      {
       LuaUnlock(D.L);
       D.status=D.writer(D.L,b,size,D.data);
       LuaLock(D.L);
      }
 }

 public static int LuaUDump(LuaState L, Proto f, lua_Writer w, object data, int strip)
 {
     DumpState D = new DumpState();
      D.L=L;
      D.writer=w;
      D.data=data;
      D.strip=strip;
      D.status=0;
      DumpHeader(D);
      DumpFunction(f,null,D);
      return D.status;
 }

 static void DumpVector(object b, int n, DumpState D)
 {
     DumpInt(n,D);
      DumpMem(b, n, D);
 }

 private static void DumpString(TString s, DumpState D)
 {
     if (s==null || GetStr(s)==null)
      {
       uint size=0;
       DumpVar(size,D);
      }
      else
      {
       uint size=s.tsv.len+1;		/* include trailing '\0' */
       DumpVar(size,D);
       DumpBlock(GetStr(s),size,D);
      }
 }

 private static void DumpNumber(LuaNumberType x, DumpState D)
 {
     DumpVar(x,D);
 }

 private static void DumpInt(int x, DumpState D)
 {
     DumpVar(x,D);
 }

 private static void DumpHeader(DumpState D)
 {
     CharPtr h = new char[LUAC_HEADERSIZE];
      luaU_header(h);
      DumpBlock(h,LUAC_HEADERSIZE,D);
 }

 private static void DumpFunction(Proto f, TString p, DumpState D)
 {
     DumpString( ((f.source==p) || (D.strip!=0)) ? null : f.source, D);
      DumpInt(f.linedefined,D);
      DumpInt(f.lastlinedefined,D);
      DumpChar(f.nups,D);
      DumpChar(f.numparams,D);
      DumpChar(f.is_vararg,D);
      DumpChar(f.maxstacksize,D);
      DumpCode(f,D);
      DumpConstants(f,D);
      DumpDebug(f,D);
 }

        public static void DumpMem(object b, DumpState D)
        {
            #if XBOX
            // todo: implement this - mjf
            Debug.Assert(false);
            #endif

            #if SILVERLIGHT
            // No support for Marshal.SizeOf in Silverlight, so we
            // have to manually set the size. Size values are from
            // Lua's 5.1 spec.

            // No support for Marshal.StructureToPtr in Silverlight,
            // let's use BitConverter instead!

            int size = 0;
            byte[] bytes;
            Type t = b.GetType();
            if (t.Equals(typeof(UInt32)))
            {
                size = 4;
                bytes = BitConverter.GetBytes((uint)b);
            }
            else if (t.Equals(typeof(Int32)))
            {
                size = 4;
                bytes = BitConverter.GetBytes((int)b);
            }
            else if (t.Equals(typeof(Char)))
            {
                size = 1;
                bytes = new byte[1] { BitConverter.GetBytes((char)b)[0] };
            }
            else if (t.Equals(typeof(Byte)))
            {
                size = 1;
                bytes = new byte[1] { (byte)b };
                //bytes = BitConverter.GetBytes((byte)b);
            }
            else if (t.Equals(typeof(Double)))
            {
                size = 8;
                bytes = BitConverter.GetBytes((double)b);
            }
            else
            {
                throw new NotImplementedException("Invalid type: " + t.FullName);
            }

            #else
            int size = Marshal.SizeOf(b);
            IntPtr ptr = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(b, ptr, false);
            byte[] bytes = new byte[size];
            Marshal.Copy(ptr, bytes, 0, size);
            #endif
            char[] ch = new char[bytes.Length];
            for (int i = 0; i < bytes.Length; i++)
                ch[i] = (char)bytes[i];
            CharPtr str = ch;
            DumpBlock(str, (uint)str.chars.Length, D);

            #if !SILVERLIGHT
            Marshal.Release(ptr);
            #endif
        }

 public static void DumpVar(object x, DumpState D)
 {
     DumpMem(x, D);
 }

 private static void WriteUOL(WZUOLProperty node, DumpState ds, BinaryWriter bw) {
     ds.AddNode(node);
     bw.Write(ds.AddString(node.Name));
     ds.AddUOL(node, bw.BaseStream.Position);
     bw.Write(0L);
     bw.Write(0L);
 }

 private static void DumpCode(Proto f, DumpState D)
 {
     DumpInt(f.sizecode, D);
     for (int i = 0; i < f.sizecode; i++)
         DumpInt((int)f.code[i], D);
 }

 private static void DumpNumber(lua_Number x, DumpState D)
 {
     DumpMem(BitConverter.GetBytes(x), D);
 }

 private static void DumpInt(int x, DumpState D)
 {
     byte[] b = BitConverter.GetBytes((UInt32) x);
     if (!BitConverter.IsLittleEndian)
         Array.Reverse(b);
     DumpMem(b, D);
 }

 private static void DumpByte(int y, DumpState D)
 {
     byte[] x = new byte[1];
     x[0] = (byte)y;
     DumpMem(x, D);
 }

 private static void WriteNodeLevel(ref List<WZObject> nodeLevel, DumpState ds, BinaryWriter bw) {
     uint nextChildId = (uint) (ds.GetNextNodeID() + nodeLevel.Count);
     foreach (WZObject levelNode in nodeLevel) {
         if (levelNode is WZUOLProperty)
             WriteUOL((WZUOLProperty) levelNode, ds, bw);
         else
             WriteNode(levelNode, ds, bw, nextChildId);
         nextChildId += (uint) levelNode.ChildCount;
     }
     List<WZObject> @out = new List<WZObject>();
     foreach (WZObject levelNode in nodeLevel.Where(n => n.ChildCount > 0))
         @out.AddRange(levelNode.OrderBy(f => f.Name, StringComparer.Ordinal));
     nodeLevel.Clear();
     nodeLevel = @out;
 }

 private static void DumpCode(Proto f,DumpState D)
 {
     DumpVector(f.code, f.sizecode, D);
 }