Пример #1
0
        private void AppendSection(XmlDocumentWrapper xml, XmlNode main, ImportFunctionSection s)
        {
            if (main == null || s == null || s.Count <= 0)
            {
                return;
            }

            XmlNode imports = xml.CreateElement(NodeImports);

            if (imports == null)
            {
                return;
            }

            // serialize all the import sections:
            foreach (ImportFunctionModule desc in s.Modules)
            {
                XmlNode m = SerializeImportModule(xml, desc);

                if (m != null)
                {
                    imports.AppendChild(m);
                }
            }

            main.AppendChild(imports);
        }
Пример #2
0
        private void AppendSection(XmlDocumentWrapper xml, XmlNode main, ExportFunctionSection s)
        {
            if (main == null || s == null || s.Count <= 0)
            {
                return;
            }

            XmlNode exports = xml.CreateElement(NodeExports);

            if (exports == null)
            {
                return;
            }

            foreach (ExportFunctionDescription desc in s.Functions)
            {
                XmlNode f = (desc.IsForwarded
                                 ? xml.CreateElementWithText(NodeExportsFunctionForwardedName,
                                                             desc.ForwardedName)
                                 : null);
                XmlNode e = SerializeBaseFunction(xml, desc, f);

                // append function info to exports:
                if (e != null)
                {
                    exports.AppendChild(e);
                }
            }

            // store:
            main.AppendChild(exports);
        }
Пример #3
0
        private XmlNode SerializeBaseFunction(XmlDocumentWrapper xml, BaseFunctionDescription desc, XmlNode optional)
        {
            XmlNode e = xml.CreateElement(NodeFunction);
            XmlNode n = xml.CreateElementWithText(NodeFunctionName, desc.Name);
            XmlNode o = xml.CreateElementWithText(NodeFunctionOrdinal, desc.Ordinal.ToString());
            XmlNode a = xml.CreateElementWithText(NodeFunctionAddress,
                                                  "0x" + desc.VirtualAddress.ToString("X8"));

            // append all info about given function:
            if (n != null)
            {
                e.AppendChild(n);
            }
            if (optional != null)
            {
                e.AppendChild(optional);
            }
            if (o != null)
            {
                e.AppendChild(o);
            }
            if (a != null)
            {
                e.AppendChild(a);
            }

            return(e);
        }
Пример #4
0
        private XmlNode SerializeImportForwarder(XmlDocumentWrapper xml, ImportBoundForwarderDescription s)
        {
            XmlNode f = xml.CreateElement(NodeForwarder);

            if (f != null)
            {
                XmlNode n = xml.CreateElementWithText(NodeForwarderName, s.Name);
                XmlNode d = xml.CreateElementWithText(NodeForwarderBoundDate, s.BoundDate.ToString());

                if (n != null)
                {
                    f.AppendChild(n);
                }
                if (d != null)
                {
                    f.AppendChild(d);
                }
            }

            return(f);
        }
Пример #5
0
        private XmlNode SerializeImportModule(XmlDocumentWrapper xml, ImportFunctionModule s)
        {
            XmlNode m = xml.CreateElement(NodeImportsModule);

            if (m != null)
            {
                XmlNode n = xml.CreateElementWithText(NodeImportsModuleName, s.Name);

                if (n != null)
                {
                    m.AppendChild(n);
                }

                // serialize imported forwarders:
                foreach (ImportBoundForwarderDescription desc in s.Forwarders)
                {
                    XmlNode f = SerializeImportForwarder(xml, desc);

                    if (f != null)
                    {
                        m.AppendChild(f);
                    }
                }

                // serialize imported functions:
                foreach (ImportFunctionDescription desc in s.Functions)
                {
                    XmlNode f = SerializeBaseFunction(xml, desc, null);

                    if (f != null)
                    {
                        m.AppendChild(f);
                    }
                }
            }

            return(m);
        }