├── .gitignore
├── Allocator.cpp
├── App.config
├── AssemblyDef.cpp
├── ChangeLog.txt
├── Class.cpp
├── CodeContainer.cpp
├── CreateGUID.cpp
├── CustomAttributeContainer.cpp
├── DLLExportReader.cpp
├── DLLExportReader.h
├── DataContainer.cpp
├── DotNetPELib.h
├── DotNetPELib.sln
├── DotNetPELib.vcxproj
├── DotNetPELib.vcxproj.filters
├── DotNetPELib.vcxproj.user
├── Enum.cpp
├── Field.cpp
├── Instruction.cpp
├── MZHeader.h
├── Method.cpp
├── MethodSignature.cpp
├── NameSpace.cpp
├── NetCore.cpp
├── NetSignature.cpp
├── ObjTest
    ├── ObjTest.cpp
    ├── ObjTest.vcxproj
    ├── ObjTest.vcxproj.filters
    ├── ReadMe.txt
    ├── stdafx.cpp
    ├── stdafx.h
    └── targetver.h
├── Operand.cpp
├── PECor20Headers.cpp
├── PEFile.h
├── PEHeader.h
├── PELib.cpp
├── PELibError.cpp
├── PEReader.cpp
├── PEWriter.cpp
├── Property.cpp
├── Qualifiers.cpp
├── README.md
├── RSAEncoder.cpp
├── RSAEncoder.h
├── Type.cpp
├── Value.cpp
├── appveyor.yml
├── bigd license.txt
├── bigdigits.cpp
├── bigdigits.h
├── bigdtypes.h
├── copying
├── docs
    ├── Allocator.html
    ├── AssemblyDef.html
    ├── BoxedType.html
    ├── Class.html
    ├── CodeContainer.html
    ├── CustomAttributeContainer.html
    ├── DataContainer.html
    ├── DotNETPELib 3.0 Documentation.html
    ├── Enum.html
    ├── Field.html
    ├── FieldName.html
    ├── Instruction.html
    ├── Local.html
    ├── Method.html
    ├── MethodName.html
    ├── MethodSignature.html
    ├── Namespace.html
    ├── Operand.html
    ├── PELib.html
    ├── PELibError.html
    ├── Param.html
    ├── Property.html
    ├── Qualifier.html
    ├── SEH.html
    ├── Type.html
    └── Value.html
├── libhostfxr
    ├── _version.h
    ├── error_codes.h
    ├── fx_ver.cpp
    ├── fx_ver.h
    ├── fxr_resolver.cpp
    ├── fxr_resolver.h
    ├── fxrutils.cpp
    ├── fxrutils.h
    ├── hostfxr.h
    ├── libhostfxr.vcxproj
    ├── libhostfxr.vcxproj.filters
    ├── longfile.h
    ├── longfile.windows.cpp
    ├── pal.h
    ├── pal.windows.cpp
    ├── runtime_version.h
    ├── trace.cpp
    └── trace.h
├── license.txt
├── ms.bat
├── netlink
    ├── CmdFiles.cpp
    ├── CmdFiles.h
    ├── CmdSwitch.cpp
    ├── CmdSwitch.h
    ├── NetLink.vcxproj
    ├── NetLink.vcxproj.filters
    ├── NetLink.vcxproj.user
    ├── NetLinkMain.cpp
    ├── NetLinkMain.h
    ├── ToolChain.cpp
    ├── ToolChain.h
    ├── Utils.cpp
    ├── Utils.h
    ├── dummy.cpp
    ├── makefile
    ├── netlink.exe.manifest
    ├── targetver.h
    └── version.h
├── sha1.cpp
├── sha1.h
├── targetver.h
├── test
    ├── App.config
    ├── DumpMSCorLib.cpp
    ├── DumpMSCorLib.vcxproj
    ├── DumpMSCorLib.vcxproj.filters
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── test.cpp
    ├── test.vcxproj
    ├── test.vcxproj.filters
    ├── testcsc.cs
    └── testcsc.csproj
├── testcore
    ├── test.cpp
    ├── testcore.vcxproj
    └── testcore.vcxproj.filters
├── util
    ├── dump.c
    └── dump.cpp
├── vcvars32.bat
└── vcvarsall.bat


/.gitignore:
--------------------------------------------------------------------------------
1 | .vs
2 | *.db
3 | release
4 | debug


--------------------------------------------------------------------------------
/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/ChangeLog.txt:
--------------------------------------------------------------------------------
  1 | Version 4.00:
  2 |         add license.txt and copying files
  3 |         update for .net core
  4 |         update as per latest from orange c
  5 |         support at least parsing the CMOD_OPT and CMOD_REQD type elements
  6 |         handle reading pointer/array types better
  7 |         allow loading of dlls that don't have exactly five corelib streams
  8 |         allow loading of dlls that use the alternate location for the pointers to the cor20 header structure
  9 |         search for managed libraries on the path
 10 |         elide unused variables from function argument lists:
 11 |         fix bugs in optimizing locals
 12 | 
 13 | Version 3.04:
 14 |         make use of maps with strings a little faster
 15 | 
 16 | Version 3.03:
 17 | 	add support for explicit types (for sizeof)
 18 | 	add support for pinning
 19 | 	add support for generic classes and allow find functions to match by generic arguments
 20 |         add minimal support for generic functions (find not updated)
 21 |         add qualifiers for virtual/newslot
 22 |         add qualifier for runtime functions
 23 |         remove old 'virtual' functions
 24 | 
 25 | Version 3.02:
 26 | 	fix problems parsing and generating properties
 27 | 	allow 'find' functions to find constructors
 28 | 
 29 | Version 3.01:
 30 | 	support virtual functions
 31 | 	use correct boxed types 'Byte and SByte' for the 8-bit values
 32 |     speed up assembly loading a little
 33 |     make read of ILO files more portable
 34 |     make the sources compileable by mingw64 and clang
 35 | 
 36 | Version 3.00:
 37 | 	support SEH
 38 | 
 39 | Version 2.12:
 40 | 	allow boxing of 'object' and creation of arrays of objects
 41 | 
 42 | Version 2.11:
 43 |     support extends for classes
 44 | 
 45 | Version 2.10:
 46 | 	bug fix:  escape '"' and '\' in ldstr operand
 47 | 	bug fix:  fix a crash
 48 | 	bug fix:  handle enum references properly and load enum values
 49 | 
 50 | Version 2.9:
 51 | 	bug fix:  allow System.Diagnostics.Process to load
 52 | 
 53 | Version 2.8:
 54 | 	bug fix:  if a global field is of type class and the class is from an external assembly ref,
 55 | 			  the IL file wass correct but the PE file had a bad signature for the field's type
 56 | 	bug fix:  last property in a long list of properties could be loaded incorrectly
 57 | 	netlink:  don't thunk C-style entry point if the incoming program has an entry point
 58 | 	bug fix:  custom attributes not registered correctly
 59 | 
 60 | Version 2.7:
 61 | 	various improvements to property creation
 62 | 	bug fix: fix the problem with quoted types in external assemblies in a better way
 63 | 
 64 | Version 2.6:
 65 | 	bug fix: search for assembly on path failed
 66 | 
 67 | Version 2.5:
 68 | 	bug fix: escape control characters when writing strings to the .il file...
 69 | 	bug fix: don't quote types from external assemblies
 70 | 	bug fix: fix crash when System.Windows.dll is loaded
 71 | 
 72 | Version 2.4:
 73 | 	bug fix: in some assemblies parent classes sometimes are listed AFTER the child classes, which resulted in a crash
 74 | 	bug fix: name and box native integers properly
 75 | 
 76 | Version 2.3:
 77 | 	bug fix: using namespace.cls in an object file failed for empty method signatures
 78 | 	bug fix: integers were being maxed at 2gigs because of use of atoi
 79 | 
 80 | Version 2.2:
 81 |     add routines to read and write object files
 82 |     add a linker to link object files
 83 |     bug fix: add the valuetype flag to the qualifiers on enumerations
 84 |     bug fix: ldarg instruction was considered to have five bytes, not 4.   This could mess up branch generation if
 85 |              there are hundreds of arguments
 86 |     bug fix: the object[] variable used for setup for calling VARARG functions was declared as void * in the locals,
 87 | 		.NET was ok with it but MONO was too restrictive to accept it.
 88 |     bug fix: allocator could call a destructor for unconstructed memory on close
 89 |     bug fix: fix the 'dump' utility to work with the latest code base
 90 | 
 91 | Version 2.1:
 92 |     speed up GAC searches
 93 |     allow searching for a specific version of a DLL in the GAC.
 94 |     add support for 'explicit' classes
 95 |     fix bug: allow boxing of 'string' type
 96 | 
 97 | Version 2.0:
 98 |     read public members of assemblies into the internal database - searches the GAC or takes the path of an assembly
 99 |     add support for simple properties
100 |     add support for arrays and remove 'objectarray' type
101 |     add support for 'ref' argument types
102 |     fully support assembly versions
103 |     cache the custom attribute database for purposes of being able to parse files; 
104 |         in general you cannot declare custom attributes though
105 |     add lookup functions to find assembly members of referenced assemblies
106 |     clean up some duplicate definitions in the API.
107 |     update demo code to use new APIs.
108 |     add new demos
109 |     fix bug: integer constants were being represented in hexadecimal in the .il file
110 |     fix bug: in the IL src types were quoted in boxing and newarr
111 | 
112 | Version 1.2:
113 |     remove sdata section; move the data into the CIL data section (fix for avast
114 |         not liking generated files)
115 |     add strong name key hashing
116 |     fix bug putting large data in the blob
117 | 
118 | Version 1.1:
119 |     fix problems with generating the binary for large programs
120 | 
121 | Version 1.0:
122 |     initial release
123 | 
124 | 


--------------------------------------------------------------------------------
/CreateGUID.cpp:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #include <random>
26 | #include <array>
27 | #include <algorithm>
28 | #include <functional>
29 | #include "DotNetPELib.h"
30 | #include "PEFile.h"
31 | 
32 | void DotNetPELib::PEWriter::CreateGuid(Byte* Guid)
33 | {
34 |     std::array<unsigned char, 128 / 8> rnd;
35 | 
36 |     std::uniform_int_distribution<int> distribution(0, 0xff);
37 |     // note that this whole thing will fall apart if the C++ lib uses
38 |     // a prng with constant seed for the random_device implementation.
39 |     // that shouldn't be a problem on OS we are interested in.
40 |     std::random_device dev;
41 |     std::mt19937 engine(dev());
42 |     auto generator = std::bind(distribution, engine);
43 | 
44 |     std::generate(rnd.begin(), rnd.end(), generator);
45 | 
46 |     // make it a valid version 4 (random) GUID
47 |     // remember that on windows GUIDs are native endianness so this may need
48 |     // work if you port it
49 |     rnd[7 /*6*/] &= 0xf;
50 |     rnd[7 /*6*/] |= 0x40;
51 |     rnd[9 /*8*/] &= 0x3f;
52 |     rnd[9 /*8*/] |= 0x80;
53 | 
54 |     memcpy(Guid, rnd.data(), rnd.size());
55 | }
56 | 


--------------------------------------------------------------------------------
/DLLExportReader.cpp:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #include <cstdio>
 26 | #include <cstring>
 27 | #include "DLLExportReader.h"
 28 | #include "DotNetPELib.h"
 29 | #include "PEHeader.h"
 30 | #include "MZHeader.h"
 31 | 
 32 | #include "PEFile.h"
 33 | using namespace DotNetPELib;
 34 | 
 35 | const char* DIR_SEP = "\\";
 36 | 
 37 | DLLExportReader::~DLLExportReader()
 38 | {
 39 |     for (iterator it = begin(); it != end(); ++it)
 40 |     {
 41 |         DLLExport* p = *it;
 42 |         delete p;
 43 |     }
 44 | }
 45 | 
 46 | bool DLLExportReader::FindDLL()
 47 | {
 48 |     char* p = (char*)strrchr((char*)name.c_str(), '.');
 49 |     if (!p || p[1] == DIR_SEP[0])
 50 |     {
 51 |         name += ".dll";
 52 |     }
 53 |     // just try to open the file
 54 |     // this will catch absolute files and files relative to the current directory
 55 |     FILE* fil = fopen(name.c_str(), "rb");
 56 |     if (fil)
 57 |     {
 58 |         fclose(fil);
 59 |         return true;
 60 |     }
 61 |     // now look in windows/system32
 62 |     p = getenv("SystemRoot");
 63 |     if (p)
 64 |     {
 65 |         char buf[260];
 66 |         StrCpy(buf, p);
 67 |         if (buf[strlen(buf) - 1] != DIR_SEP[0])
 68 |             StrCat(buf, DIR_SEP);
 69 |         StrCat(buf, "System32");
 70 |         StrCat(buf, DIR_SEP);
 71 |         StrCat(buf, name.c_str());
 72 |         fil = fopen(buf, "rb");
 73 |         if (fil)
 74 |         {
 75 |             name = buf;
 76 |             fclose(fil);
 77 |             return true;
 78 |         }
 79 |     }
 80 |     // now search the path
 81 |     p = getenv("PATH");
 82 |     if (p)
 83 |     {
 84 |         while (*p)
 85 |         {
 86 |             char buf[260], *q = buf;
 87 |             while (*p && *p != ';')
 88 |                 *q++ = *p++;
 89 |             *q = 0;
 90 |             if (*p)
 91 |                 p++;
 92 |             if (buf[strlen(buf) - 1] != DIR_SEP[0])
 93 |                 StrCat(buf, DIR_SEP);
 94 |             StrCat(buf, name.c_str());
 95 |             fil = fopen(buf, "rb");
 96 |             if (fil)
 97 |             {
 98 |                 name = buf;
 99 |                 fclose(fil);
100 |                 return true;
101 |             }
102 |         }
103 |     }
104 |     return false;
105 | }
106 | bool DLLExportReader::doExports(std::fstream& in, int phys, int rva)
107 | {
108 |     in.seekg(phys);
109 |     if (!in.fail())
110 |     {
111 |         PEExportHeader eh;
112 |         in.read((char*)&eh, sizeof(eh));
113 |         for (int i = 0; i < eh.n_name_ptrs; i++)
114 |         {
115 |             int nameptr;
116 |             short ord = 0;
117 |             char buf[256];
118 |             bool byOrd;
119 |             buf[0] = 0;
120 |             in.seekg(eh.name_rva - rva + phys + i * 4);
121 |             in.read((char*)&nameptr, sizeof(nameptr));
122 |             if (nameptr)
123 |             {
124 |                 in.seekg(nameptr - rva + phys);
125 |                 in.read(buf, 256);
126 |                 buf[255] = 0;  // just in case
127 |                 byOrd = false;
128 |             }
129 |             else
130 |             {
131 |                 byOrd = true;
132 |             }
133 |             in.seekg(eh.ordinal_rva - rva + phys + i * 2);
134 |             in.read((char*)&ord, sizeof(ord));
135 |             exports.push_back(new DLLExport(buf, ord, byOrd));
136 |         }
137 |     }
138 |     return !in.fail();
139 | }
140 | bool DLLExportReader::LoadExports()
141 | {
142 |     bool rv = false;
143 |     std::fstream in(name.c_str(), std::ios::in | std::ios::binary);
144 |     if (!in.fail())
145 |     {
146 |         MZHeader mzh;
147 |         in.read((char*)&mzh, sizeof(mzh));
148 |         if (!in.fail() && mzh.signature == MZ_SIGNATURE)
149 |         {
150 |             // seek to the position where the offset to the PEHeader is stored
151 |             in.seekg(mzh.n_header_paragraphs * 16 - 4);
152 |             int pos;
153 |             in.read((char*)&pos, sizeof(pos));
154 |             if (!in.fail())
155 |             {
156 |                 in.seekg(pos);
157 |                 if (!in.fail())
158 |                 {
159 |                     PEHeader peh;
160 |                     in.read((char*)&peh, sizeof(peh));
161 |                     if (!in.fail() && peh.signature == PESIG)
162 |                     {
163 |                         for (int i = 0; i < peh.num_objects; i++)
164 |                         {
165 |                             PEObject obj;
166 |                             in.read((char*)&obj, sizeof(obj));
167 |                             if (!in.fail())
168 |                             {
169 |                                 if (peh.export_rva >= obj.virtual_addr && peh.export_rva < obj.virtual_addr + obj.virtual_size)
170 |                                 {
171 |                                     rv = doExports(in, obj.raw_ptr + peh.export_rva - obj.virtual_addr, peh.export_rva);
172 |                                     break;
173 |                                 }
174 |                             }
175 |                         }
176 |                     }
177 |                 }
178 |             }
179 |         }
180 |     }
181 |     return rv;
182 | }


--------------------------------------------------------------------------------
/DLLExportReader.h:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #ifndef DLLExportReader_H
26 | #define DLLExportReader_H
27 | 
28 | #include <string>
29 | #include <fstream>
30 | #include <deque>
31 | 
32 | struct DLLExport
33 | {
34 |     DLLExport(const std::string &Name, int ord, bool ByOrd) : name(Name), ordinal(ord), byOrd(ByOrd) { }
35 |     std::string name;
36 |     int ordinal;
37 |     bool byOrd;
38 | };
39 | 
40 | class DLLExportReader
41 | {
42 | public:
43 |     DLLExportReader(const std::string &fname) : name(fname) { }
44 |     ~DLLExportReader();
45 |     bool Read() { bool rv = FindDLL(); if (rv) rv = LoadExports(); return rv; }
46 | 
47 |     std::string Name() { return name; }
48 |     typedef std::deque<DLLExport *>::iterator iterator;
49 |     iterator begin() { return exports.begin(); }
50 |     iterator end() { return exports.end(); }
51 | protected:
52 |     bool doExports(std::fstream &in, int phys, int rva);
53 |     bool FindDLL();
54 |     bool LoadExports();
55 | private:
56 |     std::string name;
57 |     std::deque<DLLExport *> exports;
58 | };
59 | #endif
60 | 


--------------------------------------------------------------------------------
/DotNetPELib.vcxproj.filters:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup>
  4 |     <Filter Include="Source Files">
  5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
  6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
  7 |     </Filter>
  8 |     <Filter Include="Header Files">
  9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
 10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
 11 |     </Filter>
 12 |     <Filter Include="Resource Files">
 13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
 14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
 15 |     </Filter>
 16 |   </ItemGroup>
 17 |   <ItemGroup>
 18 |     <ClInclude Include="DLLExportReader.h">
 19 |       <Filter>Header Files</Filter>
 20 |     </ClInclude>
 21 |     <ClInclude Include="DotNetPELib.h">
 22 |       <Filter>Header Files</Filter>
 23 |     </ClInclude>
 24 |     <ClInclude Include="MZHeader.h">
 25 |       <Filter>Header Files</Filter>
 26 |     </ClInclude>
 27 |     <ClInclude Include="PEFile.h">
 28 |       <Filter>Header Files</Filter>
 29 |     </ClInclude>
 30 |     <ClInclude Include="PEHeader.h">
 31 |       <Filter>Header Files</Filter>
 32 |     </ClInclude>
 33 |     <ClInclude Include="bigdigits.h">
 34 |       <Filter>Header Files</Filter>
 35 |     </ClInclude>
 36 |     <ClInclude Include="bigdtypes.h">
 37 |       <Filter>Header Files</Filter>
 38 |     </ClInclude>
 39 |     <ClInclude Include="sha1.h">
 40 |       <Filter>Header Files</Filter>
 41 |     </ClInclude>
 42 |     <ClInclude Include="RSAEncoder.h">
 43 |       <Filter>Header Files</Filter>
 44 |     </ClInclude>
 45 |     <ClInclude Include="targetver.h">
 46 |       <Filter>Resource Files</Filter>
 47 |     </ClInclude>
 48 |   </ItemGroup>
 49 |   <ItemGroup>
 50 |     <ClCompile Include="Allocator.cpp">
 51 |       <Filter>Source Files</Filter>
 52 |     </ClCompile>
 53 |     <ClCompile Include="AssemblyDef.cpp">
 54 |       <Filter>Source Files</Filter>
 55 |     </ClCompile>
 56 |     <ClCompile Include="Class.cpp">
 57 |       <Filter>Source Files</Filter>
 58 |     </ClCompile>
 59 |     <ClCompile Include="CodeContainer.cpp">
 60 |       <Filter>Source Files</Filter>
 61 |     </ClCompile>
 62 |     <ClCompile Include="CreateGUID.cpp">
 63 |       <Filter>Source Files</Filter>
 64 |     </ClCompile>
 65 |     <ClCompile Include="DataContainer.cpp">
 66 |       <Filter>Source Files</Filter>
 67 |     </ClCompile>
 68 |     <ClCompile Include="DLLExportReader.cpp">
 69 |       <Filter>Source Files</Filter>
 70 |     </ClCompile>
 71 |     <ClCompile Include="Enum.cpp">
 72 |       <Filter>Source Files</Filter>
 73 |     </ClCompile>
 74 |     <ClCompile Include="Field.cpp">
 75 |       <Filter>Source Files</Filter>
 76 |     </ClCompile>
 77 |     <ClCompile Include="Instruction.cpp">
 78 |       <Filter>Source Files</Filter>
 79 |     </ClCompile>
 80 |     <ClCompile Include="Method.cpp">
 81 |       <Filter>Source Files</Filter>
 82 |     </ClCompile>
 83 |     <ClCompile Include="MethodSignature.cpp">
 84 |       <Filter>Source Files</Filter>
 85 |     </ClCompile>
 86 |     <ClCompile Include="NameSpace.cpp">
 87 |       <Filter>Source Files</Filter>
 88 |     </ClCompile>
 89 |     <ClCompile Include="NetSignature.cpp">
 90 |       <Filter>Source Files</Filter>
 91 |     </ClCompile>
 92 |     <ClCompile Include="Operand.cpp">
 93 |       <Filter>Source Files</Filter>
 94 |     </ClCompile>
 95 |     <ClCompile Include="PELib.cpp">
 96 |       <Filter>Source Files</Filter>
 97 |     </ClCompile>
 98 |     <ClCompile Include="PELibError.cpp">
 99 |       <Filter>Source Files</Filter>
100 |     </ClCompile>
101 |     <ClCompile Include="Qualifiers.cpp">
102 |       <Filter>Source Files</Filter>
103 |     </ClCompile>
104 |     <ClCompile Include="Type.cpp">
105 |       <Filter>Source Files</Filter>
106 |     </ClCompile>
107 |     <ClCompile Include="Value.cpp">
108 |       <Filter>Source Files</Filter>
109 |     </ClCompile>
110 |     <ClCompile Include="sha1.cpp">
111 |       <Filter>Source Files</Filter>
112 |     </ClCompile>
113 |     <ClCompile Include="RSAEncoder.cpp">
114 |       <Filter>Source Files</Filter>
115 |     </ClCompile>
116 |     <ClCompile Include="bigdigits.cpp">
117 |       <Filter>Source Files</Filter>
118 |     </ClCompile>
119 |     <ClCompile Include="PECor20Headers.cpp">
120 |       <Filter>Source Files</Filter>
121 |     </ClCompile>
122 |     <ClCompile Include="PEReader.cpp">
123 |       <Filter>Source Files</Filter>
124 |     </ClCompile>
125 |     <ClCompile Include="PEWriter.cpp">
126 |       <Filter>Source Files</Filter>
127 |     </ClCompile>
128 |     <ClCompile Include="Property.cpp">
129 |       <Filter>Source Files</Filter>
130 |     </ClCompile>
131 |     <ClCompile Include="CustomAttributeContainer.cpp">
132 |       <Filter>Source Files</Filter>
133 |     </ClCompile>
134 |     <ClCompile Include="NetCore.cpp">
135 |       <Filter>Source Files</Filter>
136 |     </ClCompile>
137 |   </ItemGroup>
138 |   <ItemGroup>
139 |     <Text Include="ReadMe.txt">
140 |       <Filter>Source Files</Filter>
141 |     </Text>
142 |     <Text Include="ChangeLog.txt" />
143 |   </ItemGroup>
144 | </Project>


--------------------------------------------------------------------------------
/DotNetPELib.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup />
4 | </Project>


--------------------------------------------------------------------------------
/MZHeader.h:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #ifndef MZHeader_h
26 | #define MZHeader_h
27 | 
28 | #define MZ_SIGNATURE 0x5A4D /* MZ */
29 | 
30 | struct MZHeader
31 | {
32 |     unsigned short signature;
33 |     unsigned short image_length_MOD_512;
34 |     unsigned short image_length_DIV_512;
35 |     unsigned short n_relocation_items;
36 |     unsigned short n_header_paragraphs;
37 |     unsigned short min_paragraphs_above;
38 |     unsigned short max_paragraphs_above;
39 |     unsigned short initial_SS;
40 |     unsigned short initial_SP;
41 |     unsigned short checksum;
42 |     unsigned short initial_IP;
43 |     unsigned short initial_CS;
44 |     unsigned short offset_to_relocation_table;
45 |     unsigned short overlay;
46 |     unsigned short always_one;
47 | };
48 | #endif
49 | 


--------------------------------------------------------------------------------
/NameSpace.cpp:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #include "DotNetPELib.h"
26 | #include "PEFile.h"
27 | namespace DotNetPELib
28 | {
29 | 
30 | bool Namespace::ILSrcDump(PELib& peLib) const
31 | {
32 | 
33 |     peLib.Out() << ".namespace '" << name_ << "' {" << std::endl;
34 |     DataContainer::ILSrcDump(peLib);
35 |     peLib.Out() << "}" << std::endl;
36 |     return true;
37 | }
38 | void Namespace::ObjOut(PELib& peLib, int pass) const
39 | {
40 |     peLib.Out() << std::endl << "$nb" << peLib.FormatName(name_);
41 |     DataContainer::ObjOut(peLib, pass);
42 |     peLib.Out() << std::endl << "$ne";
43 | }
44 | Namespace* Namespace::ObjIn(PELib& peLib, bool definition)
45 | {
46 |     // always a definition (never used as an operand)
47 |     std::string name = peLib.UnformatName();
48 |     Namespace *temp, *rv = nullptr;
49 |     temp = (Namespace*)peLib.GetContainer()->FindContainer(name);
50 |     if (temp && typeid(*temp) != typeid(Namespace))
51 |         peLib.ObjError(oe_nonamespace);
52 |     if (!temp)
53 |         rv = temp = peLib.AllocateNamespace(name);
54 |     ((DataContainer*)temp)->ObjIn(peLib);
55 |     if (peLib.ObjEnd() != 'n')
56 |         peLib.ObjError(oe_syntax);
57 |     return rv;
58 | }
59 | std::string Namespace::ReverseName(DataContainer* child)
60 | {
61 |     std::string rv;
62 |     if (child->Parent())
63 |     {
64 |         if (child->Parent()->Parent())
65 |             rv = ReverseName(child->Parent()) + ".";
66 |         rv += child->Name();
67 |     }
68 |     return rv;
69 | }
70 | bool Namespace::PEDump(PELib& peLib)
71 | {
72 |     if (!InAssemblyRef() || !PEIndex())
73 |     {
74 |         std::string fullName = ReverseName(this);
75 |         peIndex_ = peLib.PEOut().HashString(fullName);
76 |     }
77 |     if (!InAssemblyRef())
78 |         DataContainer::PEDump(peLib);
79 |     return true;
80 | }
81 | }  // namespace DotNetPELib


--------------------------------------------------------------------------------
/ObjTest/ObjTest.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <Text Include="ReadMe.txt" />
19 |   </ItemGroup>
20 |   <ItemGroup>
21 |     <ClInclude Include="stdafx.h">
22 |       <Filter>Header Files</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="targetver.h">
25 |       <Filter>Header Files</Filter>
26 |     </ClInclude>
27 |   </ItemGroup>
28 |   <ItemGroup>
29 |     <ClCompile Include="stdafx.cpp">
30 |       <Filter>Source Files</Filter>
31 |     </ClCompile>
32 |     <ClCompile Include="ObjTest.cpp">
33 |       <Filter>Source Files</Filter>
34 |     </ClCompile>
35 |   </ItemGroup>
36 | </Project>


--------------------------------------------------------------------------------
/ObjTest/ReadMe.txt:
--------------------------------------------------------------------------------
 1 | ========================================================================
 2 |     CONSOLE APPLICATION : q Project Overview
 3 | ========================================================================
 4 | 
 5 | AppWizard has created this q application for you.
 6 | 
 7 | This file contains a summary of what you will find in each of the files that
 8 | make up your q application.
 9 | 
10 | 
11 | q.vcxproj
12 |     This is the main project file for VC++ projects generated using an Application Wizard.
13 |     It contains information about the version of Visual C++ that generated the file, and
14 |     information about the platforms, configurations, and project features selected with the
15 |     Application Wizard.
16 | 
17 | q.vcxproj.filters
18 |     This is the filters file for VC++ projects generated using an Application Wizard. 
19 |     It contains information about the association between the files in your project 
20 |     and the filters. This association is used in the IDE to show grouping of files with
21 |     similar extensions under a specific node (for e.g. ".cpp" files are associated with the
22 |     "Source Files" filter).
23 | 
24 | q.cpp
25 |     This is the main application source file.
26 | 
27 | /////////////////////////////////////////////////////////////////////////////
28 | Other standard files:
29 | 
30 | StdAfx.h, StdAfx.cpp
31 |     These files are used to build a precompiled header (PCH) file
32 |     named q.pch and a precompiled types file named StdAfx.obj.
33 | 
34 | /////////////////////////////////////////////////////////////////////////////
35 | Other notes:
36 | 
37 | AppWizard uses "TODO:" comments to indicate parts of the source code you
38 | should add to or customize.
39 | 
40 | /////////////////////////////////////////////////////////////////////////////
41 | 


--------------------------------------------------------------------------------
/ObjTest/stdafx.cpp:
--------------------------------------------------------------------------------
1 | // stdafx.cpp : source file that includes just the standard includes
2 | // q.pch will be the pre-compiled header
3 | // stdafx.obj will contain the pre-compiled type information
4 | 
5 | #include "stdafx.h"
6 | 
7 | // TODO: reference any additional headers you need in STDAFX.H
8 | // and not in this file
9 | 


--------------------------------------------------------------------------------
/ObjTest/stdafx.h:
--------------------------------------------------------------------------------
 1 | // stdafx.h : include file for standard system include files,
 2 | // or project specific include files that are used frequently, but
 3 | // are changed infrequently
 4 | //
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "targetver.h"
 9 | 
10 | #include <stdio.h>
11 | #include <tchar.h>
12 | 
13 | 
14 | 
15 | // TODO: reference additional headers your program requires here
16 | 


--------------------------------------------------------------------------------
/ObjTest/targetver.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Including SDKDDKVer.h defines the highest available Windows platform.
4 | 
5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
7 | 
8 | #include <SDKDDKVer.h>
9 | 


--------------------------------------------------------------------------------
/PELibError.cpp:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #include "DotNetPELib.h"
26 | namespace DotNetPELib
27 | {
28 | const char* PELibError::errorNames[] = {
29 |     "Variable Length Argument parameters already declared",
30 |     "Stack underflow",
31 |     "Mismatched stack at label",
32 |     "Stack not empty at end of function",
33 |     "Duplicate label",
34 |     "Missing label",
35 |     "Short branch out of range",
36 |     "Index out of range",
37 |     "Multiple Entry Points",
38 |     "Missing Entry Point",
39 |     "Expected SEH Try block",
40 |     "Expected SEH Handler",
41 |     "SEH Tag Mismatch",
42 |     "Orphaned SEH Tag",
43 |     "Invalid SEH Filter",
44 |     "Invalid epilogue of SEH section",
45 | };
46 | }


--------------------------------------------------------------------------------
/Qualifiers.cpp:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #include "DotNetPELib.h"
 26 | namespace DotNetPELib
 27 | {
 28 | const char* Qualifiers::qualifierNames_[] = {"public",
 29 |                                              "private",
 30 |                                              "static",
 31 |                                              "instance",
 32 |                                              "explicit",
 33 |                                              "ansi",
 34 |                                              "sealed",
 35 |                                              "enum",
 36 |                                              "value",
 37 |                                              "sequential",
 38 |                                              "auto",
 39 |                                              "literal",
 40 |                                              "hidebysig",
 41 |                                              "preservesig",
 42 |                                              "specialname",
 43 |                                              "rtspecialname",
 44 |                                              "cil",
 45 |                                              "managed",
 46 |                                              "runtime",
 47 |                                              "",
 48 |                                              "virtual",
 49 |                                              "newslot",
 50 |                                              "beforefieldinit",
 51 |                                              "",
 52 |                                              "",
 53 |                                              "",
 54 |                                              "",
 55 |                                              "",
 56 |                                              "",
 57 |                                              "",
 58 |                                              "",
 59 |                                              ""};
 60 | int Qualifiers::afterFlags_ = Qualifiers::PreserveSig | Qualifiers::CIL | Qualifiers::Managed | Qualifiers::Runtime;
 61 | void Qualifiers::ILSrcDumpBeforeFlags(PELib& peLib) const
 62 | {
 63 |     int n = ~afterFlags_ & flags_;
 64 |     for (int i = 0; i < 32; i++)
 65 |         if (n & (1 << i))
 66 |             peLib.Out() << " " << qualifierNames_[i];
 67 | }
 68 | void Qualifiers::ILSrcDumpAfterFlags(PELib& peLib) const
 69 | {
 70 |     int n = afterFlags_ & flags_;
 71 |     for (int i = 0; i < 32; i++)
 72 |         if (n & (1 << i))
 73 |             peLib.Out() << " " << qualifierNames_[i];
 74 | }
 75 | void Qualifiers::ObjOut(PELib& peLib, int pass) const { peLib.Out() << flags_; }
 76 | void Qualifiers::ObjIn(PELib& peLib, bool definition) { flags_ = peLib.ObjInt(); }
 77 | void Qualifiers::ReverseNamePrefix(std::string& rv, const DataContainer* parent, int& pos, bool type)
 78 | {
 79 |     if (parent)
 80 |     {
 81 |         ReverseNamePrefix(rv, parent->Parent(), pos, type);
 82 |         if (pos != 0)
 83 |         {
 84 |             rv += parent->Name();
 85 |             if (typeid(*parent) == typeid(Class) && (!parent->Parent() || typeid(*(parent->Parent())) != typeid(Class)))
 86 |                 rv += type ? "\xf8" : "/";
 87 |             else
 88 |                 rv += '.';
 89 |         }
 90 |         else if (typeid(*parent) == typeid(AssemblyDef))
 91 |         {
 92 |             if (parent->InAssemblyRef())
 93 |             {
 94 |                 rv += std::string("[") + parent->Name() + "]";
 95 |             }
 96 |         }
 97 |         pos++;
 98 |     }
 99 | }
100 | std::string Qualifiers::GetNamePrefix(const DataContainer* parent, bool type)
101 | {
102 |     std::string rv;
103 |     if (parent)
104 |     {
105 |         int pos = 0;
106 |         ReverseNamePrefix(rv, parent, pos, type);
107 |     }
108 |     return rv;
109 | }
110 | std::string Qualifiers::GetName(const std::string& root, const DataContainer* parent, bool type)
111 | {
112 |     std::string rv = GetNamePrefix(parent, type);
113 |     if (rv.size())
114 |     {
115 |         rv = rv.substr(0, rv.size() - 1);
116 |     }
117 |     if (root.size())
118 |     {
119 |         if (rv.size())
120 |             rv += "::";
121 |         rv += "'" + root + "'";
122 |     }
123 |     return rv;
124 | }
125 | 
126 | std::string Qualifiers::GetObjName(const std::string& stem, const DataContainer* parent)
127 | {
128 |     int pos = 0;
129 |     std::string rv;
130 |     ReverseNamePrefix(rv, parent, pos, false);
131 |     int npos = rv.find('/');
132 |     if (npos != std::string::npos)
133 |         rv[npos] = '.';
134 |     if (rv.size())
135 |     {
136 |         if (rv[rv.size() - 1] == '.')
137 |         {
138 |             if (rv.size() == 1)
139 |                 rv = "";
140 |             else
141 |                 rv = rv.substr(0, rv.size() - 1);
142 |         }
143 |     }
144 |     if (stem.size())
145 |     {
146 |         if (rv.size())
147 |         {
148 |             rv = rv + "::" + stem;
149 |         }
150 |         else
151 |         {
152 |             rv = stem;
153 |         }
154 |     }
155 |     return rv;
156 | }
157 | }  // namespace DotNetPELib


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DotNetPELib
 2 | 
 3 | DotNetPELib is a library which abstracts managed information such as namespaces, classes, fields, methods, properties, and instructions.  The information can then be used to generate intermediate language source files, or PE executables or DLLs.
 4 | 
 5 | Build Status
 6 | [![Build status](https://ci.appveyor.com/api/projects/status/rtuxe2ef8w7udjda?svg=true)](https://ci.appveyor.com/project/LADSoft/dotnetpelib)
 7 | 
 8 | The library has been tested as the backend for the OCCIL compiler, and is reasonably functional.  That said this version of the library does have various limitations; not all aspects of the managed environment are enabled at this time.
 9 | 
10 | In addition to being able to generate .net programs, version 2.0 of the library has support for importing managed assemblies, and strong names.   See 'changelog.txt' for a full description of the changes.
11 | 
12 | Version 2.2 of the library introduces read/write of a simple object file format in the familiar object-file-per-module paradigm, along with a linker.
13 | 
14 | A simple test program is included which generates several example executables in both IL and EXE format.
15 | 
16 | The project files are for Visual Studio 2017 community edition.   This source code does use some of the new features in C++11.
17 | 
18 | 


--------------------------------------------------------------------------------
/RSAEncoder.cpp:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #include <cstdio>
 26 | #include <climits>
 27 | #include <cstring>
 28 | #include <random>
 29 | #include <functional>
 30 | #include <algorithm>
 31 | #include "RSAEncoder.h"
 32 | #include "sha1.h"
 33 | #include "bigdigits.h"
 34 | #include "limits.h"
 35 | 
 36 | namespace DotNetPELib
 37 | {
 38 | 
 39 | Byte PKCS1Formatter::DerHeader[] = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14};
 40 | 
 41 | void PKCS1Formatter::Calculate(ByteArray& result)
 42 | {
 43 |     memset(result(), 0xff, result.size());
 44 |     result[0] = 0;
 45 |     result[1] = 1;
 46 |     int pos = result.size() - 20 - sizeof(DerHeader) - 1;
 47 |     result[pos] = 0;
 48 |     memcpy(result() + pos + 1, DerHeader, sizeof(DerHeader));
 49 |     memcpy(result() + result.size() - 20, msg_, 20);
 50 |     // reverse it before encryption..
 51 |     for (int i = 0; i < result.size() / 2; i++)
 52 |     {
 53 |         int temp = result[i];
 54 |         result[i] = result[result.size() - i - 1];
 55 |         result[result.size() - i - 1] = temp;
 56 |     }
 57 | }
 58 | size_t RSAEncoder::LoadStrongNameKeys(const std::string& file)
 59 | {
 60 |     int rv = 0;
 61 |     FILE* fil = fopen(file.c_str(), "rb");
 62 |     if (fil)
 63 |     {
 64 |         static Byte test[] = {0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32};
 65 |         Byte buf[0x14];
 66 |         if (fread(buf, 1, 0x14, fil) == 0x14 && !memcmp(buf, test, sizeof(test)))
 67 |         {
 68 |             modulusBits = *(int*)(buf + sizeof(test));
 69 |             modulus = new Byte[2048];
 70 |             privateExponent = new Byte[2048];
 71 |             keyPair = new Byte[2048];
 72 |             publicExponent = *(DWord*)(buf + sizeof(test) + 4);
 73 |             if (fread(modulus, 1, modulusBits / 8, fil) == modulusBits / 8)
 74 |             {
 75 |                 if (!fseek(fil, 5 * modulusBits / 16, SEEK_CUR))
 76 |                 {
 77 |                     if (fread(privateExponent, 1, modulusBits / 8, fil) == modulusBits / 8)
 78 |                     {
 79 |                         if (!fseek(fil, 0, SEEK_SET))
 80 |                         {
 81 |                             if (fread(keyPair, 1, modulusBits / 8 + 0x14, fil) == modulusBits / 8 + 0x14)
 82 |                             {
 83 |                                 rv = modulusBits / 8;
 84 |                             }
 85 |                         }
 86 |                     }
 87 |                 }
 88 |             }
 89 |         }
 90 |         fclose(fil);
 91 |     }
 92 |     return rv;
 93 | }
 94 | void RSAEncoder::GetPublicKeyData(Byte* key, size_t* keySize)
 95 | {
 96 |     DIGIT_T* dkey = (DIGIT_T*)key;
 97 |     dkey[0] = 0x2400;
 98 |     dkey[1] = 0x8004;
 99 |     dkey[2] = 0x14 + modulusBits / 8;
100 |     memcpy(dkey + 3, keyPair, dkey[2]);
101 |     ((char*)dkey)[12 + 0x0b] = '1';  // change to RSA1 (pub key only)
102 |     ((char*)dkey)[12 + 0] = 6;       // change to pub key only
103 |     *keySize = dkey[2] + 12;
104 | }
105 | void RSAEncoder::GetStrongNameSignature(Byte* sig, size_t* sigSize, const Byte* hash, size_t hashSize)
106 | {
107 |     ByteArray x(modulusBits / 8);
108 |     PKCS1Formatter formatter(hash);
109 |     formatter.Calculate(x);
110 |     mpModExp((DIGIT_T*)sig, (DIGIT_T*)x(), (DIGIT_T*)privateExponent, (DIGIT_T*)modulus, modulusBits / 8 / sizeof(DIGIT_T));
111 |     *sigSize = modulusBits / 8;
112 | }
113 | }  // namespace DotNetPELib


--------------------------------------------------------------------------------
/RSAEncoder.h:
--------------------------------------------------------------------------------
 1 | #include "DotNetPELib.h"
 2 | #include "bigdigits.h"
 3 | namespace DotNetPELib {
 4 | 
 5 | class ByteArray
 6 | {
 7 | public:
 8 |     ByteArray(size_t len) : len_(len), mem_(new Byte[len]) { memset(mem_,0, len_); }
 9 |     ~ByteArray()
10 |     {
11 |         memset(mem_, 0, len_);
12 |         delete[] mem_;
13 |     }
14 |     
15 |     Byte *operator()() { return mem_; }
16 |     const Byte *operator()() const { return mem_; }
17 |     Byte &operator[](size_t pos) { return *(mem_ + pos); }
18 |     size_t size() { return len_; }
19 | 
20 |     Byte *begin() { return mem_; }
21 |     Byte *end() { return mem_ + len_; }
22 | private:
23 |     Byte *mem_;
24 |     size_t len_;
25 | };
26 | // format a message hash into PKCS1 format
27 | // assumes SHA-1 hashing
28 | class PKCS1Formatter
29 | {
30 |     public:
31 |         PKCS1Formatter(const Byte *msg) : msg_(msg) { }
32 |         void Calculate(ByteArray &result);
33 |     private:
34 |         const Byte *msg_;
35 |         static Byte DerHeader[];
36 | };
37 | 
38 | // Manage SNK file & perform RSA signature
39 | class RSAEncoder
40 | {
41 |     public:
42 | 	RSAEncoder() : modulusBits(0), privateExponent(0), publicExponent(0), keyPair(0), modulus(0) { }
43 | 	virtual ~RSAEncoder() { 
44 |         if (privateExponent)
45 |             memset(privateExponent, 0, 2048);
46 |         if (keyPair)
47 |             memset(keyPair, 0, 2048);
48 |         if (modulus)
49 |             memset(modulus, 0, 2048);
50 | 		delete [] privateExponent;
51 | 		delete [] keyPair;
52 | 		delete [] modulus;
53 | 	}
54 | 	size_t LoadStrongNameKeys(const std::string & file);
55 | 	void GetPublicKeyData(Byte *key, size_t *keySize);
56 | 	void GetStrongNameSignature(Byte *sig, size_t *sigSize, const Byte *hash, size_t hashSize );
57 | 
58 | //private:
59 | 	size_t modulusBits;
60 |     int publicExponent;
61 | 	Byte *privateExponent;
62 | 	Byte *keyPair;
63 | 	Byte *modulus;
64 | };
65 | }


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | image: Visual Studio 2022
 2 | 
 3 | build_script:
 4 |         - ps: "cd ..\\..; move projects\\DotNetPELib .; cd DotNetPELib; .\\ms; cd ..; move DotNetPELib projects"
 5 | 
 6 | artifacts:
 7 |   - path: "Release\\DotNetPELib.lib"
 8 |     name: DotNetPELib
 9 |   - path: "Release\\NetLink.exe"
10 |     name: NetLink
11 |   - path: "DotNetPELib.h"
12 |     name: Header File


--------------------------------------------------------------------------------
/bigdigits.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LADSoft/DotNetPELib/8282f8a7ef7bc53ad5f443a9c382ce91d89c3aee/bigdigits.cpp


--------------------------------------------------------------------------------
/bigdtypes.h:
--------------------------------------------------------------------------------
 1 | /* $Id: bigdtypes.h $ */
 2 | 
 3 | /***** BEGIN LICENSE BLOCK *****
 4 |  *
 5 |  * This Source Code Form is subject to the terms of the Mozilla Public
 6 |  * License, v. 2.0. If a copy of the MPL was not distributed with this
 7 |  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 8 |  *
 9 |  * Copyright (c) 2001-16 David Ireland, D.I. Management Services Pty Limited
10 |  * <http://www.di-mgt.com.au/bigdigits.html>. All rights reserved.
11 |  *
12 |  ***** END LICENSE BLOCK *****/
13 | /*
14 |  * Last updated:
15 |  * $Date: 2016-03-31 09:51:00 $
16 |  * $Revision: 2.6.1 $
17 |  * $Author: dai $
18 |  */
19 | 
20 | #ifndef BIGDTYPES_H_
21 | #define BIGDTYPES_H_ 1
22 | 
23 | #include <cstddef>
24 | 
25 | /*
26 | The following PP instructions assume that all Linux systems have a C99-conforming 
27 | <cstdint>; that other Unix systems have the uint32_t definitions in <sys/types.h>;
28 | and that MS et al don't have them at all. This version assumes that a long is 32 bits.
29 | Adjust if necessary to suit your system. 
30 | You can override by defining HAVE_C99INCLUDES or HAVE_SYS_TYPES.
31 | */
32 | 
33 | #ifndef EXACT_INTS_DEFINED_
34 | #define EXACT_INTS_DEFINED_ 1
35 | #ifndef HAVE_C99INCLUDES
36 | 	#if (__STDC_VERSION >= 199901L) || defined(linux) || defined(__linux__) || defined(__APPLE__)
37 | 	#define HAVE_C99INCLUDES
38 | 	#endif
39 | #endif
40 | #ifndef HAVE_SYS_TYPES
41 | 	#if defined(unix) || defined(__unix__)
42 | 	#define HAVE_SYS_TYPES
43 | 	#endif
44 | #endif
45 | #ifdef HAVE_C99INCLUDES
46 | 	#include <cstdint>
47 | #elif defined(HAVE_SYS_TYPES)
48 | 	#include <sys/types.h>
49 | #else 
50 | 	#define uint32_t unsigned long 
51 | 	#define uint16_t unsigned short
52 | 	#define uint8_t unsigned char
53 | #endif	/* HAVE_C99INCLUDES */
54 | #endif	/* EXACT_INTS_DEFINED_ */
55 | 
56 | /* Macros for format specifiers 
57 | -- change to "u", "x" and "X" if necessary */
58 | #ifdef HAVE_C99INCLUDES
59 | 	#include <cinttypes>
60 | #else 
61 | 	#define PRIu32 "lu" 
62 | 	#define PRIx32 "lx" 
63 | 	#define PRIX32 "lX" 
64 | #endif
65 | /* We define our own 
66 | -- Example: ``printf("%" PRIxBIGD "\n", d);`` */
67 | #define PRIuBIGD PRIu32
68 | #define PRIxBIGD PRIx32
69 | #define PRIXBIGD PRIX32
70 | 
71 | #endif /* BIGDTYPES_H_ */
72 | 


--------------------------------------------------------------------------------
/docs/Allocator.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  2 | <html>
  3 |   <head>
  4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  5 |     <title>DotNetPELib - Allocator</title>
  6 |   </head>
  7 |   <body>
  8 |     <div align="center"><font size="+3">Allocator<br>
  9 |       </font>
 10 |       <div align="left"><br>
 11 |         Allocator allocates and manages memory related to the various
 12 |         constructors used by the objects in DotNetPELib.&nbsp;&nbsp;
 13 |         When the Allocator object is destroyed, all objects allocated
 14 |         through it will be destructed and then destroyed.&nbsp;&nbsp;
 15 |         The main DotNetPELib class <a href="PELib.html">PELib</a>
 16 |         derives from allocator, and may be used interchangeably with it.<br>
 17 |         <br>
 18 |         Following is a summary of the supported allocators.&nbsp;&nbsp;
 19 |         These generally related to constructors on a one to one basis.<br>
 20 |         <br>
 21 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; AssemblyDef
 22 |           *AllocateAssemblyDef(std::string Name, bool External, Byte
 23 |           *KeyToken = 0);</b><b><br>
 24 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Namespace
 25 |           *AllocateNamespace(std::string Name);</b><b><br>
 26 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Class
 27 |           *AllocateClass(std::string Name, Qualifiers Flags, int Pack,
 28 |           int Size);</b><b><br>
 29 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Method
 30 |           *AllocateMethod(MethodSignature *Prototype, Qualifiers flags,
 31 |           bool entry = false);</b><b><br>
 32 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Field
 33 |           *AllocateField(std::string Name, Type *tp, Qualifiers Flags);</b><b><br>
 34 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Property
 35 |           *AllocateProperty(PELib &amp; peLib, std::string name, Type
 36 |           *type, std::vector&lt;Type *&gt;&amp; indices, bool hasSetter
 37 |           = true, DataContainer *parent = nullptr);</b><b><br>
 38 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Property
 39 |           *AllocateProperty();</b><b><br>
 40 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Enum
 41 |           *AllocateEnum(std::string Name, Qualifiers Flags,
 42 |           Field::ValueSize Size);</b><b><br>
 43 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 44 |           *AllocateOperand();</b><b><br>
 45 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 46 |           *AllocateOperand(Value *V);</b><b><br>
 47 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 48 |           *AllocateOperand(longlong Value, Operand::OpSize Size);</b><b><br>
 49 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 50 |           *AllocateOperand(int Value, Operand::OpSize Size) {</b><b><br>
 51 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 52 |           return AllocateOperand((longlong)Value, Size);</b><b><br>
 53 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }</b><b><br>
 54 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 55 |           *AllocateOperand(unsigned Value, Operand::OpSize Size) {</b><b><br>
 56 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 57 |           return AllocateOperand((longlong)Value, Size);</b><b><br>
 58 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }</b><b><br>
 59 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 60 |           *AllocateOperand(double Value, Operand::OpSize Size);</b><b><br>
 61 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 62 |           *AllocateOperand(std::string Value, bool);</b><b><br>
 63 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 64 |           *AllocateOperand(std::string Value);</b><b><br>
 65 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction
 66 |           *AllocateInstruction(Instruction::iop Op, Operand *Operand =
 67 |           nullptr);</b><b><br>
 68 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction
 69 |           *AllocateInstruction(Instruction::iop Op, std::string Text);</b><b><br>
 70 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction
 71 |           *AllocateInstruction(Instruction::iseh type, bool begin, Type *catchType=nullptr);</b><b><br>
 72 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Value
 73 |           *AllocateValue(std::string name, Type *tp);</b><b><br>
 74 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Local
 75 |           *AllocateLocal(std::string name, Type *tp);</b><b><br>
 76 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Param
 77 |           *AllocateParam(std::string name, Type *tp);</b><b><br>
 78 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; FieldName
 79 |           *AllocateFieldName(Field *F);</b><b><br>
 80 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MethodName
 81 |           *AllocateMethodName(MethodSignature *M);</b><b><br>
 82 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 83 |           MethodSignature *AllocateMethodSignature(std::string Name, int
 84 |           Flags, DataContainer *Container);</b><b><br>
 85 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
 86 |           *AllocateType(Type::BasicType Tp, int PointerLevel);</b><b><br>
 87 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
 88 |           *AllocateType(DataContainer *clsref);</b><b><br>
 89 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
 90 |           *AllocateType(MethodSignature *methodref);</b><b><br>
 91 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; BoxedType
 92 |           *AllocateBoxedType(Type::BasicType Tp);</b><b><br>
 93 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Byte
 94 |           *AllocateBytes(size_t sz);</b><b><br>
 95 |         </b><br>
 96 |       </div>
 97 |     </div>
 98 |   </body>
 99 | </html>
100 | 


--------------------------------------------------------------------------------
/docs/AssemblyDef.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - AssemblyDef</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">AssemblyDef<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         Usually one would not construct an AssemblyDef object directly
12 |         either through the AssemblyDef class or with the <a
13 |           href="Allocator.html">Allocator</a> class.&nbsp;&nbsp; Instead
14 |         the object would be constructed as part of processing in the <a
15 |           href="PELib.html">PELib</a> class, or when loading an external
16 |         assembly's members.&nbsp;&nbsp; But the constructor allows for
17 |         giving the AssemblyDef a name, indicating whether it is
18 |         external, and setting the public name token.<br>
19 |         <br>
20 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
21 |           AssemblyDef(std::string Name, bool External, Byte * KeyToken =
22 |           nullptr) ;<br>
23 |           <br>
24 |         </b>It is possible to set version info for an assembly.&nbsp;
25 |         Usually, one wouldn't explicitly set the version except on the
26 |         assembly for which code is being generated, as it would be
27 |         loaded from the assembly's file.<br>
28 |         <br>
29 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
30 |           SetVersion(int major, int minor, int build, int revision);<br>
31 |           <br>
32 |         </b>Assigning an SNK file sets strong name key signing into
33 |         motion.&nbsp;&nbsp; If the file is valid, the generated assembly
34 |         will be signed.<br>
35 |         <b></b></div>
36 |     </div>
37 |     <b><br>
38 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const std::string&amp;
39 |       SNKFile() const { return snkFile_; }</b><b><br>
40 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
41 |       SNKFile(std::string file) { snkFile_ = file; }<br>
42 |       <br>
43 |     </b>If you have a referencer to an assembly, you can look up a class
44 |     within that assembly<br>
45 |     <b><br>
46 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Class
47 |       *LookupClass(PELib &amp;lib, std::string nameSpace, std::string
48 |       name);</b><b><br>
49 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
50 |       <br>
51 |     </b>It is possible to get the custom attributes associated with an
52 |     assembly, in order to examine them if necessary.&nbsp;&nbsp; At
53 |     present it is not possible to add custom attributes to a generated
54 |     assembly.<br>
55 |     <br>
56 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
57 |       CustomAttributeContainer &amp;CustomAttributes() const { return
58 |       customAttributes_;&nbsp; }<br>
59 |       <br>
60 |     </b>The following function returns true if this is an external
61 |     assembly (usually a loaded assembly such as mscorlib).&nbsp; It
62 |     returns false if it is the assembly being generated.<br>
63 |     <br>
64 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; virtual bool
65 |       InAssemblyRef() const { return external_; }</b><b><br>
66 |     </b><br>
67 |   </body>
68 | </html>
69 | 


--------------------------------------------------------------------------------
/docs/BoxedType.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - BoxedType</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">BoxedType<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         BoxedType derives from <a href="Type.html">Type</a>. It
12 |         represents the boxed version of a basic value type such as
13 |         System::Int32 instead of int32.&nbsp;&nbsp; The boxed version is
14 |         basically a class that derives from System::Object; it is useful
15 |         when a simple type needs to be treated more like a class object.
16 |         (for example when placed into an array of objects).<br>
17 |         <br>
18 |         The only useful thing to do with a BoxedType is to construct
19 |         it.&nbsp;&nbsp; It may be constructed either directly or through
20 |         an <a href="Allocator.html">Allocator</a> object.<br>
21 |         <br>
22 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
23 |           BoxedType(BasicType Tp) </b><b><br>
24 |         </b><br>
25 |         &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <br>
26 |         <br>
27 |         <br>
28 |       </div>
29 |     </div>
30 |   </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/docs/Class.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Class</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Class<br>
 9 |       </font>
10 |       <div align="left">The Class object holds the declaration for a
11 |         .Net class.&nbsp;&nbsp; A class can be an Enumeration, in fact
12 |         the <a href="Enum.html">Enum</a> object derives from
13 |         Class.&nbsp;&nbsp; The Class object derives from the <a
14 |           href="DataContainer.html">DataContainer</a> object, which
15 |         allows it to hold <a href="Method.html">Method</a> objects, <a
16 |           href="Field.html">Field</a> objects, and other Class or Enum
17 |         objects.&nbsp;&nbsp; Additionally, a class object may hold <a
18 |           href="Property.html">Property</a> objects.&nbsp;&nbsp; Note
19 |         that classes may NOT contain namespaces or assemblies.<br>
20 |         <br>
21 |         The constructor may be called either directly or through the <a
22 |           href="Allocator.html">Allocator</a> object.&nbsp;&nbsp; It
23 |         takes a name, qualifiers such as whether the class is static or
24 |         a value type, a packing value, and the size of the
25 |         object.&nbsp;&nbsp; If the pack value and size of the object are
26 |         both set to -1, these attributes will not be generated for the
27 |         class.<br>
28 |         <br>
29 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Class(std::string
30 |           Name, Qualifiers Flags, int Pack, int Size);</b><b><br>
31 |           <br>
32 |         </b>The pack value and size value may be independently set for
33 |         the class.&nbsp;&nbsp; Note that if either is set to a
34 |         non-negative value, the PE file will have an entry which sets
35 |         both anyway.<br>
36 |         <b><br>
37 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void pack(int
38 |           pk) { pack_ = pk; }</b><b><br>
39 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void size(int
40 |           sz) { size_ = sz; }<br>
41 |           <br>
42 |         </b>Classes always extend other classes in .Net.&nbsp;&nbsp; If
43 |         an extendsFrom class is not selected, the library will choose
44 |         one of the classes System.ValueType, System.Enum, or
45 |         System.Object based on whether the class is an enumeration and
46 |         the <a href="Qualifier.html">Qualifier</a> flags.<br>
47 |         <br>
48 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
49 |           Extends(Class *extendsFrom) { extendsFrom_ = extendsFrom; }<br>
50 |           <br>
51 |         </b>One can add or view class properties.&nbsp; Methods and
52 |         Fields are managed through the underlying DataContainer object.<br>
53 |         <b></b><b><br>
54 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void Add(Property
55 |           *property);</b><b><br>
56 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
57 |           std::vector&lt;Property *&gt;&amp; Properties() const { return
58 |           properties_;&nbsp; }</b><b><br>
59 |           <br>
60 |         </b>To set the fact that a class reference is to be an external reference
61 |         for purpose of the object file, use<br>
62 |         <b></b><b><br>
63 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool External() const;
64 |           </b><b><br></b>
65 |         <b></b><b>
66 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void External(bool external);
67 |           </b><b><br></b><br>
68 | 	It is possible to traverse the members of a
69 |         class.&nbsp;&nbsp; Normally though, one would start the
70 |         traversal process by calling the related <a href="PELib.html">PELib</a>
71 |         traverse function, which would traverse every object known to the
72 |         library.<br>
73 |         <br>
74 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; virtual bool
75 |           Traverse(Callback &amp;callback) const override;</b><b><br>
76 |         </b><br>
77 |       </div>
78 |     </div>
79 |   </body>
80 | </html>
81 | 


--------------------------------------------------------------------------------
/docs/CodeContainer.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - CodeContainer</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">CodeContainer<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         CodeContainers hold the body of <a href="Method.html">Method</a>
12 |         objects,&nbsp; e.g. a list of <a href="Instruction.html">Instruction</a>
13 |         objects (including labels), along with any <a
14 |           href="Operand.html">Operand</a> object required by each
15 |         instructions.<br>
16 |         <br>
17 |         Code containers are usually constructed as part of the
18 |         destruction of the derived class Method, and the constructor
19 |         will not be accessed by user code.&nbsp;&nbsp; It does however
20 |         allow setting of standard CIL flags.<br>
21 |         <br>
22 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
23 |           CodeContainer(Qualifiers Flags) :flags_(Flags);<br>
24 |           <br>
25 |         </b>An instruction may be added to the end of the container.<br>
26 |         <b><br>
27 |         </b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
28 |           AddInstruction(Instruction *instruction);</b><b><br>
29 |         </b><b><br>
30 |         </b>Sometimes it is interesting to examine or remove the last
31 |         instruction generated.<br>
32 |         <b><br>
33 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction
34 |           *RemoveLastInstruction();</b><b><br>
35 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction
36 |           *LastInstruction() const;<br>
37 |           <br>
38 |           <br>
39 |         </b>
40 |         <div align="left">When the instructions have been generated, one
41 |           can validate them directly, or one can wait to call
42 |           Method::Optimize(), which will validate them.&nbsp;&nbsp;
43 |           Validation may throw a <a href="PELibError.html">PELibError</a>
44 |           exception, with information about what is wrong.&nbsp;&nbsp;
45 |           Presently the CodeContainer will throw exceptions for misuse
46 |           of labels, and <a href="Param.html">Param</a> and <a
47 |             href="Local.html">Local</a> object indexes out of range for
48 |           the instruction in use.&nbsp;&nbsp; Method::Optimize will also
49 |           check that the stack remains balanced though.<br>
50 |           <br>
51 |         </div>
52 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
53 |           ValidateInstructions();<br>
54 | 	</b>
55 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
56 |           ValidateSEH();<br>
57 |           <br>
58 |         </b>The CIL qualifiers may be examined or modified.<br>
59 |         <br>
60 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Qualifiers
61 |           &amp;Flags() { return flags_; }</b><b><br>
62 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
63 |           Qualifiers &amp;Flags() const { return flags_; }<br>
64 |           <br>
65 |         </b>The parent container may be examined or set.&nbsp;&nbsp;
66 |         Normally, the set would take place automatically when the Method
67 |         is added to an <a href="AssemblyDef.html">AssemblyDef</a>, <a
68 |           href="Class.html">Class</a> or <a href="Namespace.html">Namespace</a>.
69 |         This is done in the <a href="DataContainer.html">DataContainer</a>
70 |         interface.<br>
71 |         <b></b><b><br>
72 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
73 |           SetContainer(DataContainer *parent) { parent_ = parent; }</b><b><br>
74 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DataContainer
75 |           *GetContainer() const { return parent_; }</b><b><br>
76 |         </b><br>
77 |       </div>
78 |     </div>
79 |   </body>
80 | </html>
81 | 


--------------------------------------------------------------------------------
/docs/CustomAttributeContainer.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - CustomAttributeContainer</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">CustomAttributeContainer<br>
 9 |         <br>
10 |       </font>
11 |       <div align="left">A CustomAttributeContainer is associated with
12 |         each loaded assembly.&nbsp; It contains a list of
13 |         CustomAttributeDescriptors.&nbsp; The CustomAttributeDescriptor
14 |         holds information about an attribute and looks as follows:<br>
15 |         <br>
16 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; class
17 |           CustomAttributeDescriptor</b><b><br>
18 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {</b><b><br>
19 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; public:</b><b><br>
20 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
21 | 
22 |           std::string name; // name of custom attribute</b><b><br>
23 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
24 | 
25 |           Byte *data; // data</b><b><br>
26 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
27 | 
28 |           size_t sz; // size of data</b><b><br>
29 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; };</b><b><br>
30 |         </b><br>
31 |         CustomAttributeContainers will never be constructed by a user in
32 |         this version of the library.&nbsp;&nbsp; <br>
33 |         <br>
34 |         Two accessors exist to locate an attribute.&nbsp;&nbsp; They use
35 |         a class defined by PEFile.h which gives information about&nbsp;
36 |         the attribute.&nbsp;&nbsp; <br>
37 |         <br>
38 |         Lookup is used to get the CustomAttributeDescriptor data.&nbsp;
39 |         In case you don't need to know the data or want to see if
40 |         specific data exists, the Has function may be used.<br>
41 |         <br>
42 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
43 |           std::vector&lt;CustomAttributeDescriptor *&gt;&amp;
44 |           Lookup(CustomAttribute *attribute) const;</b><b><br>
45 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
46 |           Has(CustomAttribute &amp;attribute, std::string name,&nbsp;
47 |           Byte *data = nullptr, size_t sz = 0) const;</b><b><br>
48 |         </b><br>
49 |         Note that on load DotNetPELib will automatically check to see if
50 |         SystemParamArrayAttribute is set for the last parameter in any
51 |         parameter list, and if so set the VARARG flag in the associated
52 |         <a href="MethodSignature.html">MethodSignature</a>.&nbsp;&nbsp;
53 |         The reverse direction works as well; the attribute will be set
54 |         for managed methods if the Method flags in include 'vararg'.<br>
55 |       </div>
56 |     </div>
57 |   </body>
58 | </html>
59 | 


--------------------------------------------------------------------------------
/docs/DataContainer.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - DataContainer</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">DataContainer<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         The data container is the base class for the various classes
12 |         that can hold other things.&nbsp;&nbsp; It can hold other
13 |         datacontainers, methods, or fields.&nbsp;&nbsp; Note that
14 |         depending on the type of DataContainer, there may be limits as
15 |         to what other DataContainer types may be held.<br>
16 |         <br>
17 |         DataContainers will never be directly constructed; the derived
18 |         class will call it as part of its own construction.&nbsp;&nbsp;
19 |         However the derived class may be user-generated when
20 |         constructing an assembly.<br>
21 |         <br>
22 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
23 |           DataContainer(std::string Name, Qualifiers Flags);</b><b><br>
24 |         </b><br>
25 |         Add another data container such as a <a href="Class.html">Class</a>
26 |         or <a href="Namespace.html">Namespace.</a><br>
27 |         <br>
28 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
29 |           Add(DataContainer *item);</b><b><br>
30 |         </b><br>
31 |         Add a <a href="Method.html">Method</a> to this data container.<br>
32 |         <br>
33 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
34 |           Add(CodeContainer *item);<br>
35 |           <br>
36 |         </b>Add a <a href="Field.html">Field</a> to this data
37 |         container.<br>
38 |         <br>
39 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
40 |           Add(Field *field);</b><b><br>
41 |         </b><b><br>
42 |         </b>Not currently used.<br>
43 |         <br>
44 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
45 |           IsInstantiated() const { return instantiated_; }</b><b><br>
46 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
47 |           SetInstantiated() { instantiated_ = true; }<br>
48 |           <br>
49 |         </b>Get the parent container.&nbsp;&nbsp; A Class, Namespace, or
50 |         <a href="AssemblyDef.html">AssemblyDef</a> object.<br>
51 |         <br>
52 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
53 |           DataContainer *Parent() const { return parent_; }<br>
54 |           <br>
55 |         </b>Get the name or CIL flags<br>
56 |         <b></b><b><br>
57 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const std::string
58 |           &amp;Name() const { return name_; }</b><b><br>
59 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Qualifiers
60 |           Flags() const { return flags_; }<br>
61 |           <br>
62 |         </b>Utilities to find a subcontainer.&nbsp; Usually called
63 |         indirectly from the <a href="PELib.html">PELib</a> object.<br>
64 |         <br>
65 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
66 |           DataContainer *FindContainer(std::string name) { return
67 |           sortedChildren_[name]; }</b><b><br>
68 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DataContainer
69 |           *FindContainer(std::vector&lt;std::string&gt;&amp; split,
70 |           size_t &amp;n);<br>
71 |           <br>
72 |         </b>Get a list of fields or methods.<br>
73 |         <br>
74 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
75 |           std::list&lt;Field *&gt;&amp;Fields() { return fields_; }</b><b><br>
76 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
77 |           std::list&lt;CodeContainer *&gt;&amp;Methods() { return
78 |           methods_; }</b><b><br>
79 |         </b><b><br>
80 |         </b>Traverse the items in this container.&nbsp; Usually not
81 |         called directly; calles as a result of calling Traverse on the
82 |         PELib object.<br>
83 |         <br>
84 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; virtual bool
85 |           Traverse(Callback &amp;callback) const;<br>
86 |           <br>
87 |         </b>Returns true if this is in an 'extern' assembly (usually
88 |         loaded)<br>
89 |         <br>
90 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; virtual
91 |           bool InAssemblyRef() const { return
92 |           parent_-&gt;InAssemblyRef(); }</b><b><br>
93 |         </b><br>
94 |       </div>
95 |     </div>
96 |   </body>
97 | </html>
98 | 


--------------------------------------------------------------------------------
/docs/Enum.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Enum</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Enum<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     An enum is a helper object which basically handles augmenting a
14 |     basic class with the elements needed for C# to consider the class as
15 |     a list of enumeration constants.&nbsp;&nbsp; A field in an
16 |     enumeration usually has the qualifiers 'static' and 'literal'<br>
17 |     <br>
18 |     The enumerator would be constructed either directly or by calling
19 |     its destructor on the <a href="Allocator.html">Allocator</a>
20 |     object.&nbsp;&nbsp; Here Size gives the size of the enumeration e.g.
21 |     8 bits, 16 bits, 32 bits, 64 bits...<br>
22 |     <br>
23 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum ValueSize { i8,
24 |       i16, i32, i64 };</b><br>
25 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Enum::Enum(std::string
26 |       Name, Qualifiers Flags, Field::ValueSize Size) ;<br>
27 |       <br>
28 |     </b>AddValue is a helper which completely generates an enumeration
29 |     value.<br>
30 |     <br>
31 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
32 |       AddValue(Allocator &amp;allocator, std::string Name, longlong
33 |       Value);</b><b><br>
34 |     </b><br>
35 |   </body>
36 | </html>
37 | 


--------------------------------------------------------------------------------
/docs/Field.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Field</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Field<br>
 9 |       </font>
10 |       <div align="left">A Field is a member of a <a href="Class.html">Class</a>
11 |         object which holds data.&nbsp;&nbsp; Fields may also be members
12 |         of <a href="Enum.html">Enum</a> objects, but this is usually
13 |         handled in the background by DotNetPELib.&nbsp;&nbsp; In some
14 |         cases, it is possible to generate a field directly into an <a
15 |           href="AssemblyDef.html">AssemblyDef</a> object, however, such
16 |         fields cannot be accessed from other assemblies.<br>
17 |         <br>
18 |         A Field would be constructed either directly, or through the <a
19 |           href="Allocator.html">Allocator</a> object.&nbsp;&nbsp; It
20 |         might also be constructed indirectly, when constructing an
21 |         enumerated value with functions in the <a href="Enum.html">Enum</a>
22 |         object.&nbsp;&nbsp; All fields have a <a href="Type.html">Type</a>
23 |         indicating what sort of data is stored in the Field.<br>
24 |         <br>
25 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
26 |           Field::Field(std::string Name, Type *tp, Qualifiers Flags) ;</b><b><br>
27 |         </b><br>
28 |         A field can have a value.&nbsp;&nbsp; Usually, an enumerated
29 |         value would be added through calls in the Enum
30 |         object.&nbsp;&nbsp; Other types of binary initializers may be
31 |         added; for example occil uses initialization values to support
32 |         constant strings in the C language.&nbsp; Initializer values are
33 |         currently stored in managed memory (Older versions of the
34 |         library stored them in unmanaged memory).<br>
35 |         <br>
36 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum ValueSize {
37 |           i8, i16, i32, i64 };<br>
38 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
39 |           AddEnumValue(longlong Value, ValueSize Size);</b><b><br>
40 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
41 |           AddInitializer(Byte *bytes, int len);</b><b><br>
42 |           <br>
43 |         </b>Get the name of the field.<br>
44 |         <b><br>
45 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
46 |           std::string &amp;Name() const { return name_; }<br>
47 |           <br>
48 |         </b>Get/Set the name of the parent class.&nbsp;&nbsp; It is
49 |         usually set automatically when the Field is added to the Class.<br>
50 |         <b></b><b><br>
51 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
52 |           SetContainer(DataContainer *Parent) { parent_ = Parent; }</b><b><br>
53 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DataContainer
54 |           *GetContainer() const { return parent_; }<br>
55 |           <br>
56 |         </b>Get/Set the field's type.<br>
57 |         <br>
58 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
59 |           *FieldType() const { return type_; }</b><b><br>
60 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
61 |           FieldType(Type *tp) { type_ = tp; }<br>
62 |           <br>
63 |         </b>Get the CIL qualifiers<br>
64 |         <br>
65 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
66 |           Qualifiers &amp;Flags() const { return flags_; }<br>
67 |           <br>
68 |         </b>Not currently used.<br>
69 |         <br>
70 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
71 |           Ref(bool Ref) { ref_ = Ref; }<br>
72 |         </b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
73 |           IsRef() const { return ref_; }<br>
74 |           <br>
75 | 	</b>Get/set the 'external' flag (used by the linker)<br>
76 |         <br>
77 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
78 |           External(bool external) { external_ = External; }<br>
79 |         </b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
80 |           External() const { return external_; }<br>
81 |           <br>
82 |         </b>Get/Set the field's .NET explicit offset.&nbsp;&nbsp; For
83 |         example set the class qualifiers to 'explicit' and then set all
84 |         its fields to an explicitOffset of zero to make a
85 |         union.&nbsp;&nbsp; explicitOffsets may also be used for
86 |         'sequential' classes.<br>
87 |         <br>
88 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
89 |           ExplicitOffset(size_t offset) { explicitOffset_ = offset;}</b><b><br>
90 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; size_t
91 |           ExplicitOffset() const { return explicitOffset_; }</b><b><br>
92 |         </b><br>
93 |       </div>
94 |     </div>
95 |   </body>
96 | </html>
97 | 


--------------------------------------------------------------------------------
/docs/FieldName.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - FieldName</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">FieldName<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     A FieldName is a kind of <a href="Value.html">Value</a> that may be
14 |     used as an <a href="Operand.html">Operand</a> to an <a
15 |       href="Instruction.html">Instruction</a>.&nbsp; It references a <a
16 |       href="Field.html">Field</a> definition.&nbsp;&nbsp; It may be used
17 |     in an <a href="Operand.html">Operand</a> to an <a
18 |       href="Instruction.html">Instruction</a>.&nbsp;&nbsp; It lets the
19 |     Instruction reference a member of a <a href="Class.html">Class</a>.&nbsp;&nbsp;
20 | 
21 |     Note that fields may also be placed directly in an <a
22 |       href="AssemblyDef.html">AssemblyDef</a>, the FieldName would be
23 |     used to reference those as well.<br>
24 |     <br>
25 |     A FieldName may be constructed either directly or through the <a
26 |       href="Allocator.html">Allocator</a> object.<br>
27 |     <br>
28 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; FieldName(Field *F);</b><b><br>
29 |     </b><b><br>
30 |     </b>It is possible to get the field reference.<br>
31 |     <b><br>
32 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Field *GetField()
33 |       const { return field_; }</b><b><br>
34 |     </b><br>
35 |   </body>
36 | </html>
37 | 


--------------------------------------------------------------------------------
/docs/Instruction.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  2 | <html>
  3 |   <head>
  4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  5 |     <title>DotNetPELib - Instruction</title>
  6 |   </head>
  7 |   <body>
  8 |     <div align="center"><font size="+3">Instruction<br>
  9 |       </font>
 10 |       <div align="left"><br>
 11 |         An Instruction is placed in a <a href="Method.html">Method</a>,
 12 |         as part of the definition of the runtime behavior of the
 13 |         method.&nbsp;&nbsp; Instructions have various types of <a
 14 |           href="Operand.html">Operands</a>, which modify the behavior of
 15 |         the instruction.<br>
 16 |         <br>
 17 |         Each MSIL instruction has an enumerated name, formed by adding
 18 |         i_ at the front and replacing dots with underscores. <br>
 19 |         <br>
 20 |         For example:<br>
 21 |         <br>
 22 |         &nbsp;&nbsp;&nbsp; add becomes i_add<br>
 23 |         &nbsp;&nbsp;&nbsp; ldc.i4.4 becomes i_ldc_i4_4<br>
 24 |         <br>
 25 |         there are three special instructions<br>
 26 |         <br>
 27 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 28 | 
 29 | 
 30 |         i_label,&nbsp;&nbsp;&nbsp; // puts a label at this point in the
 31 |         instruction stream<br>
 32 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 33 | 
 34 | 
 35 |         i_comment, // puts a comment at this point in the instruction
 36 |         stream<br>
 37 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 38 | 
 39 | 
 40 |         i_seh,&nbsp;&nbsp;&nbsp; // puts an SEH region boundary at his point
 41 |         in the module code.<br>
 42 |         <br>
 43 |         The instruction may be constructed either directly or through an
 44 |         <a href="Allocator.html">Allocator</a> object.&nbsp;&nbsp;&nbsp;
 45 |         The first form of the constructor creates a generic instruction,
 46 |         including a label.&nbsp;&nbsp; The second form embeds a comment
 47 |         into the .IL source file.&nbsp; The third form embeds an <a href="SEH.html">SEH</a> boundary.
 48 |         Note that the complete list of instructions as listed in ECMA-335 
 49 |         is available for use.<br>
 50 |         <br>
 51 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction(iop
 52 |           Op, Operand *Operand);</b><b><br>
 53 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 54 |           Instruction(iop Op, std::string Text);</b><b><br>
 55 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 56 |           Instruction(iseh type, bool begin, Type *catchType);</b><b><br>
 57 |         </b><b><br>
 58 |         </b>Access the opcode<br>
 59 |         <br>
 60 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iop OpCode() const
 61 |           { return op_; }</b><b><br>
 62 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 63 |           OpCode(iop Op) { op_ = Op; }<br>
 64 |           <br>
 65 |         </b>Add a lable to a 'switch' instruction.&nbsp; Labels must be
 66 |         added in order.<br>
 67 |         <br>
 68 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 69 |           AddCaseLabel(std::string label);<br>
 70 |           <br>
 71 |         </b>Get the list of switch labels<br>
 72 |         <br>
 73 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 74 |           std::list&lt;std::string&gt; * GetSwitches() { return
 75 |           switches_; }<br>
 76 |           <br>
 77 |         </b>Get an operand for instructions that don't require an
 78 |         operand.<br>
 79 |         <b></b><b><br>
 80 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 81 |           NullOperand(Allocator &amp;allocator);<br>
 82 |           <br>
 83 |         </b>Retrieve the operand.<br>
 84 |         <br>
 85 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand
 86 |           *GetOperand() const { return operand_; }<br>
 87 |           <br>
 88 |         </b>Retrieve the comment text.<br>
 89 |         <b><br>
 90 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; std::string
 91 |           Text() const { return text_; }</b><b><br>
 92 |           <br>
 93 |         </b>Retrieve any label associated with the
 94 |         instruction.&nbsp;&nbsp; Note that labels are strings in this
 95 |         implementation (they are converted to offsets when generating
 96 |         CIL code).<br>
 97 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; std::string
 98 |           Label() const;<br>
 99 |           <br>
100 |         </b>Retrieve the size of the instruction.<br>
101 |         <br>
102 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int
103 |           InstructionSize();<br>
104 |           <br>
105 |         </b>Retrieve the stack usage of the instruction.&nbsp;&nbsp; 0 =
106 |         no effect, &gt;0 = stack grows, &lt;0 = stack shrinks<br>
107 |         <br>
108 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int StackUsage();</b><b><br>
109 |         </b><br>
110 |       </div>
111 |     </div>
112 |   </body>
113 | </html>
114 | 


--------------------------------------------------------------------------------
/docs/Local.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Local</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Local<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     Local is a type <a href="Value.html">Value</a> that may be used as
14 |     an <a href="Operand.html">Operand</a>.&nbsp;&nbsp; It describes
15 |     access to a local variable.&nbsp;&nbsp; Local variables are used
16 |     inside of <a href="Method.html">Methods</a>.<br>
17 |     <br>
18 |     The only useful thing to do with a local is construct it, either
19 |     directly or through the <a href="Allocator.html">Allocator</a>
20 |     object.<br>
21 |     <br>
22 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Local(std::string
23 |       Name, Type *Tp);</b><b><br>
24 |     </b><br>
25 |     Note that local variables are optimized - they are allocated in the
26 |     order starting with most used first.&nbsp;&nbsp; This allows more
27 |     optimal forms of the instructions to be generated for variables that
28 |     are more heavily used.<br>
29 |     <br>
30 |     <br>
31 |   </body>
32 | </html>
33 | 


--------------------------------------------------------------------------------
/docs/Method.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Method</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Method<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     A Method is the container for code.&nbsp;&nbsp; It inherits from <a
14 |       href="CodeContainer.html">CodeContainer</a>, to hold the
15 |     instructions in the function, and holds a <a
16 |       href="MethodSignature.html">MethodSignature</a> which defines the
17 |     function's signature.&nbsp;&nbsp; It also holds a list of local
18 |     variables.&nbsp;&nbsp; A method is usually stored in a class, but
19 |     can be stored in an <a href="AssemblyDef.html">AssemblyDef</a> as
20 |     well if it isn't needed outside the assembly.<br>
21 |     <br>
22 |     The Method may be constructed either directly or through the <a
23 |       href="Allocator.html">Allocator</a> object.&nbsp;&nbsp; Prior to
24 |     constructing it a MethodSignature must be constructed.&nbsp;&nbsp;
25 |     Note that 'entry' is set to true for the entry point of the
26 |     module.&nbsp;&nbsp; An entry point is not needed for DLL files.<br>
27 |     <br>
28 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Method(MethodSignature
29 |       *Prototype, Qualifiers flags, bool entry = false);</b><b><br>
30 |     </b><br>
31 |     The method may be a PInvoke Method.&nbsp;&nbsp; These methods don't
32 |     have a body, but reference an external DLL and give a calling
33 |     convention to call unmanaged code.<br>
34 |     <br>
35 |     <b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum InvokeType {
36 |         Cdecl, Stdcall };</b><b><br>
37 |         <br>
38 |       </b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
39 |       SetPInvoke(std::string name, InvokeType type = Stdcall);</b><b><br>
40 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool IsPInvoke()
41 |       const { return invokeMode_ == PInvoke; }</b><b><br>
42 |       <br>
43 |     </b>Add a local variable<br>
44 |     <br>
45 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void AddLocal(Local
46 |       *local);</b><b><br>
47 |     </b><b><br>
48 |     </b>Whether the Method needs a this pointer.<br>
49 |     <br>
50 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void Instance(bool
51 |       instance);</b><b><br>
52 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool Instance() {
53 |       return !!(Flags().Value &amp; Qualifiers::Instance); }<br>
54 |       <br>
55 |     </b>Method signature<br>
56 |     <br>
57 |     <b> </b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
58 |       MethodSignature *Signature() const { return prototype_; }</b><b><br>
59 |     </b><b><br>
60 |     </b>Iterate through the local variables<br>
61 |     <b><br>
62 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; typedef
63 |       std::vector&lt;Local *&gt;::iterator iterator;</b><b><br>
64 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator begin() {
65 |       return varList_.begin(); }</b><b><br>
66 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator end() {
67 |       return varList_.end(); }</b><b><br>
68 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; size_t size()
69 |       const { return varList_.size(); }</b><b><br>
70 |     </b><b><br>
71 |     </b>Validate and optimize the MSIL code.&nbsp;&nbsp; Throw a <a
72 |       href="PELibError.html">PELibError</a> exception if any problems
73 |     are found.<br>
74 |     <br>
75 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; virtual void
76 |       Optimize(PELib &amp;) override;<br>
77 |       <br>
78 |     </b>Determine if the method is an entry point.<br>
79 |     <br>
80 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
81 |       HasEntryPoint();<br>
82 |       <br>
83 |     </b><br>
84 |   </body>
85 | </html>
86 | 


--------------------------------------------------------------------------------
/docs/MethodName.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - MethodName</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">MethodName<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     MethodName is a type of <a href="Value.html">Value</a> that may be
14 |     used in an <a href="Operand.html">Operand</a> to an <a
15 |       href="Instruction.html">Instruction</a>.&nbsp;&nbsp; It references
16 |     a <a href="MethodSignature.html">MethodSignature</a>.<br>
17 |     <br>
18 |     The MethodName may be constructed either directly or through the <a
19 |       href="Allocator.html">Allocator</a> object.&nbsp; It requires that
20 |     a MethodSignature be constructed first.<br>
21 |     <br>
22 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
23 |       MethodName(MethodSignature *M);</b><b><br>
24 |     </b><br>
25 |     It is possible to retrieve the MethodSignature.<br>
26 |     <br>
27 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MethodSignature
28 |       *Signature() const { return signature_; }</b><b><br>
29 |     </b><br>
30 |   </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/docs/MethodSignature.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  2 | <html>
  3 |   <head>
  4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  5 |     <title>DotNetPELib - MethodSignature</title>
  6 |   </head>
  7 |   <body>
  8 |     <div align="center"><font size="+3">MethodSignature<br>
  9 |       </font>
 10 |       <div align="left"><br>
 11 |       </div>
 12 |     </div>
 13 |     A MethodSignature holds the interface through which a method is
 14 |     known.&nbsp; It holds things such as the return <a href="Type.html">Type</a>
 15 |     and a list of <a href="Param.html">Param</a> objects.<br>
 16 |     <br>
 17 |     The methodsignature may have a variable length argument list.&nbsp;
 18 |     In managed terms this means it has a final parameter of type
 19 |     System.Object[] to hold the variable length arguments.&nbsp;&nbsp;
 20 |     When an unmanaged function is called that has variable length
 21 |     argument list, the call site for the call needs to fully qualify the
 22 |     types of the specific arguments being used (for marshalling
 23 |     purposes).&nbsp;&nbsp; A second list of Param objects is used to
 24 |     list them out.&nbsp;&nbsp; Given the two param lists and the fact
 25 |     that it is a VARARG function, DotNetPELib will automatically
 26 |     transcribe the results as necessary for the given output type.<br>
 27 |     <br>
 28 |     The MethodSignature may be constructed either directly, or through
 29 |     the Allocator object.&nbsp;&nbsp; Flags indicates whether it is a
 30 |     vararg method, an instance method, a managed method<br>
 31 |     <b><br>
 32 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum { Vararg = 1,
 33 |       Managed = 2, InstanceFlag = 4 };<br>
 34 |       <br>
 35 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 36 |       MethodSignature(std::string Name, int Flags, DataContainer
 37 |       *Container)</b><b>;<br>
 38 |       <br>
 39 |     </b>Access the return type.<br>
 40 |     <b><br>
 41 |     </b><b></b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
 42 |       *ReturnType() const { return returnType_; }</b><b><br>
 43 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 44 |       ReturnType(Type *type)<br>
 45 |       <br>
 46 |     </b>Add a parameter.&nbsp;&nbsp; This function only successfully
 47 |     adds a parameter if the variable length argument parameter list
 48 |     hasn't been started; otherwise it throws <a href="PELibError.html">PELibError</a>.<br>
 49 |     <br>
 50 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 51 |       AddParam(Param *param)<br>
 52 |       <br>
 53 |     </b>Add a parameter to he variable length parameter list.<br>
 54 |     <br>
 55 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 56 |       AddVarargParam(Param *param);<br>
 57 |       <br>
 58 |     </b>This is used to associate a call site definition for an
 59 |     unmanaged function with Variable Lenth argument list with the main
 60 |     prototype.<br>
 61 |     <br>
 62 |     <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 63 |       SignatureParent(MethodSignature *parent) { methodParent_ = parent;
 64 |       }</b><b><br>
 65 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MethodSignature
 66 |       *SignatureParent() { return methodParent_; }<br>
 67 |       <br>
 68 |     </b>Access the container this signature goes with.<br>
 69 |     <b><br>
 70 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 71 |       SetContainer(DataContainer *container) { container_ = container; }</b><b><br>
 72 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DataContainer
 73 |       *GetContainer() const { return container_; }<br>
 74 |       <br>
 75 |     </b>Access the signature's Method name<br>
 76 |     <b></b><b><br>
 77 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const std::string
 78 |       &amp;Name() const { return name_; }</b><b><br>
 79 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 80 |       SetName(std::string Name) { name_ = Name; }<br>
 81 |       <br>
 82 |     </b>Internal use: support signatures for multidimensional array
 83 |     helper functions<br>
 84 |     <b><br>
 85 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void ArrayObject(Type *tp) {
 86 |       arrayObject_ = tp; }<br>
 87 |       <br>
 88 |     </b>Iterate through the parameter list<br>
 89 |     <b></b><b><br>
 90 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; typedef
 91 |       std::list&lt;Param *&gt;::iterator iterator;</b><b><br>
 92 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator begin() {
 93 |       return params.begin(); }</b><b><br>
 94 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator end() {
 95 |       return params.end(); }</b><b><br>
 96 |     </b><b><br>
 97 |     </b>Iterate through the variable length post-parameter list<br>
 98 |     <b><br>
 99 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; typedef
100 |       std::list&lt;Param *&gt;::iterator viterator;</b><b><br>
101 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator vbegin()
102 |       { return varargParams_.begin(); }</b><b><br>
103 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; iterator vend() {
104 |       return varargParams_.end(); }<br>
105 |       <br>
106 |     </b>Access whether it has a this pointer<br>
107 |     <b><br>
108 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void Instance(bool instance)
109 |     </b><b><br>
110 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool Instance()
111 |       const { return !!(flags_ &amp; InstanceFlag); }<br>
112 |       <br>
113 |     </b>Set the vararg flag for varargs<br>
114 |     <b></b><b><br>
115 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void SetVarargFlag() {
116 |       flags_ |= Vararg; }</b><b><br>
117 |     </b><b><br>
118 |     </b>Get the vararg, managed, and instance flags<br>
119 |     <b><br>
120 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int Flags() const {
121 |       return flags_; }<br>
122 |       <br>
123 |     </b>Access param counts.<br>
124 |     <b></b><b><br>
125 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; size_t ParamCount()
126 |       const { return params.size(); }</b><b><br>
127 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; size_t
128 |       VarargParamCount() const { return varargParams_.size(); }</b><b><br>
129 |     </b><b><br>
130 |     </b>Internal function, can be used to match the main Param list to a
131 |     list of types.<br>
132 |     <br>
133 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
134 |       Matches(std::vector&lt;Type *&gt; args);</b><b><br>
135 | 	</b><br>Get/set the 'external' flag (used by the linker)<br>
136 |         <br>
137 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
138 |           External(bool external) { external_ = External; }<br>
139 |         </b><b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
140 |           External() const { return external_; }<br>
141 |           <br>
142 |     </b><br>
143 |   </body>
144 | </html>
145 | 


--------------------------------------------------------------------------------
/docs/Namespace.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Namespace</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Namespace<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         Namespaces are the first group of containers that may be stored
12 |         in an <a href="AssemblyDef.html">AssemblyDef</a>.&nbsp;&nbsp;
13 |         They may hold other Namespaces, or <a href="Class.html">Class </a>and
14 |         <a href="Enum.html">Enum </a>objects.&nbsp; Namespace inherits
15 |         from <a href="DataContainer.html">DataContainer</a>.<br>
16 |         <br>
17 |         Namespaces may be constructed directly, or through the <a
18 |           href="Allocator.html">Allocator</a> object.<br>
19 |         <br>
20 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
21 |           Namespace::Namespace(std::string Name);</b><b><br>
22 |           <br>
23 |         </b>Get the qualified name of the Namespace.<br>
24 |         <b><br>
25 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; std::string
26 |           ReverseName(DataContainer *child);</b><b><br>
27 |         </b><br>
28 |         <br>
29 |       </div>
30 |     </div>
31 |   </body>
32 | </html>
33 | 


--------------------------------------------------------------------------------
/docs/Operand.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Operand</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Operand</font><br>
 9 |       <div align="left"><br>
10 |         An Operand is a qualifier to an instruction.&nbsp;&nbsp; It
11 |         might hold a numeric or string value, or a reference to some
12 |         other CIL entity such as a <a href="Type.html">Type</a>, a <a
13 |           href="FieldName.html">FieldName</a>, or a <a
14 |           href="Local.html">Local</a> reference.&nbsp;&nbsp; It is
15 |         usually specified for use in the constructor for an <a
16 |           href="Instruction.html">Instruction</a>.<br>
17 |         <br>
18 |         <br>
19 |         Literal values need to have a size specified.<br>
20 |         <br>
21 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum OpSize { any,
22 |           i8, u8, i16, u16, i32, u32, i64, u64, inative, r4, r8 };</b><b><br>
23 |         </b><br>
24 |         An operand may be constructed either directly or through an <a
25 |           href="Allocator.html">Allocator</a> object.&nbsp;&nbsp; There
26 |         are several constructors to create different types of Operands.<br>
27 |         <br>
28 |         Constructor for a null operand<br>
29 |         <br>
30 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Operand::Operand()
31 |           ;</b><b><br>
32 |         </b><br>
33 |         Constructor for an operand with a value that derives from Value,
34 |         for example a Local or <a href="Param.html">Param</a><br>
35 |         <br>
36 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
37 |           Operand::Operand(Value *V) :</b><b><br>
38 |         </b><b><br>
39 |         </b>Various constructors for integer values<br>
40 |         <b><br>
41 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
42 |           Operand::Operand(longlong Value, OpSize Size) </b><b><br>
43 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
44 |           Operand::Operand(int Value, OpSize Size)</b><b><br>
45 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
46 |           Operand::Operand(unsigned Value, OpSize Size) </b><b><br>
47 |           <br>
48 |         </b>Constructor for a floating point value.<br>
49 |         <b><br>
50 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
51 |           Operand::Operand(double Value, OpSize Size)</b><b><br>
52 |           <br>
53 |         </b>Constructor for a string value.&nbsp; The operand is there
54 |         purely to distinguish between this and the 'label' constructor.<br>
55 |         <b>&nbsp;<br>
56 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
57 |           Operand(std::string Value, bool) <br>
58 |           <br>
59 |         </b>Constructor for a label.<br>
60 |         <br>
61 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
62 |           Operand(std::string Value)</b><b><br>
63 |         </b><b><br>
64 |         </b>Various getters to get operand values.<br>
65 |         <br>
66 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; OpType
67 |           OperandType() const { return type_; }</b><b><br>
68 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Value *
69 |           GetValue() const { return type_ == t_value ? refValue_ :
70 |           nullptr; }</b><b><br>
71 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; longlong
72 |           IntValue() const { return intValue_; }</b><b><br>
73 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; std::string
74 |           StringValue() const { return stringValue_; }</b><b><br>
75 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; double
76 |           FloatValue() const { return floatValue_; }</b><b><br>
77 |         </b><br>
78 |       </div>
79 |     </div>
80 |   </body>
81 | </html>
82 | 


--------------------------------------------------------------------------------
/docs/PELibError.html:
--------------------------------------------------------------------------------
  1 | *<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  2 | <html>
  3 |   <head>
  4 | 
  5 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  6 |     <title>DotNetPELib - PELibError</title>
  7 |   </head>
  8 |   <body>
  9 |     <div align="center"><font size="+3">PELibError<br>
 10 |       </font>
 11 |       <div align="left">PELibError is the name of an exception that can
 12 |         be thrown, usually during validation of MSIL code.&nbsp;&nbsp;
 13 |         For example calling Method::Optimize will validate the code,
 14 |         which may throw this exception.&nbsp;&nbsp; The possible errors
 15 |         are:<br>
 16 |         <br>
 17 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum ErrorList<br>
 18 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {<br>
 19 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 20 |         ///** More params are being aded after a vararg param has been
 21 |         added<br>
 22 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 23 |         VarargParamsAlreadyDeclared,<br>
 24 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 25 |         ///** If calculations show that the stack would underflow
 26 |         somewhere in the method<br>
 27 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 28 |         StackUnderflow,<br>
 29 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 30 |         ///** A label can be reached but the paths don't agree on how
 31 |         many<br>
 32 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 33 |         // things are currently on the stack<br>
 34 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 35 |         MismatchedStack,<br>
 36 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 37 |         ///** The stack is unbalanced when the RET statement is hit<br>
 38 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 39 |         // This can mean either that there are elements on the stack in<br>
 40 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 41 |         // a function that has no return value, or there is not exactly
 42 |         '<br>
 43 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 44 |         //one element on the stack when the function has a return value.<br>
 45 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 46 |         StackNotEmpty,<br>
 47 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 48 |         ///** A label has been defined twice<br>
 49 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 50 |         DuplicateLabel,<br>
 51 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 52 |         ///** A label that has been referenced was not found<br>
 53 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 54 |         MissingLabel,<br>
 55 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 56 |         ///** the short version of some branch was requested, but the
 57 |         target<br>
 58 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 59 |         // is out of range.<br>
 60 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 61 |         ShortBranchOutOfRange,<br>
 62 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 63 |         ///** the short version of an instruction which references a<br>
 64 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 65 |         // local variable or a parameter was referenced, but the index
 66 |         is out<br>
 67 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 68 |         // of range<br>
 69 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 70 |         IndexOutOfRange,<br>
 71 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 72 |         ///** There are multiple entry points<br>
 73 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 74 |         MultipleEntryPoints,<br>
 75 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 76 |         ///** There is no entry point (note that if it is a DLL an entry
 77 |         point isn't needed)<br>
 78 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 79 |         MissingEntryPoint<br>
 80 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 81 |         ///** Expected this tag to be 'try' begin<br>
 82 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 83 |         Expected SEH Try,<br>
 84 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 85 |         ///** Expected an SEH block other than 'try'<br>
 86 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 87 |         Expected SEH handler,<br>
 88 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 89 |         ///** An end tag didn't match the begin tag<br>
 90 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 91 |         MismatchedSEHTag,<br>
 92 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 93 |         ///** an SEH begin tag has no corresponding end tag, or an end is out of sequence<br>
 94 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 95 |         OrphanedSEHTag,<br>
 96 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 97 |         ///** The filter expression is in an invalid place<br>
 98 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 99 |         InvalidSEHFilter,<br>
100 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
101 |         ///** leave, or endfinally/endfault/endfilter not used correctly<br>
102 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
103 |         InvalidSEHEpilogue,<br>
104 |         &nbsp;&nbsp;&nbsp; };<br>
105 |         <br>
106 | 
107 |           <br>
108 | 	Note that the <a href="SEH.html">SEH</a> validity checking does not 
109 |         check whether incorrect combinations of handler blocks are listed 
110 |         for a single try.
111 |       </div>
112 |     </div>
113 |   </body>
114 | </html>
115 | 


--------------------------------------------------------------------------------
/docs/Param.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Param</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Param<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |       </div>
12 |     </div>
13 |     Param is a type of <a href="Value.html">Value</a> which may be used
14 |     as an <a href="Operand.html">Operand</a> to an <a
15 |       href="Instruction.html">Instruction</a>.&nbsp;&nbsp; It is also
16 |     used in <a href="MethodSignature.html">MethodSignatures</a> to
17 |     define the method parameters.<br>
18 |     <br>
19 |     The only thing useful to be done with a Param is to construct it for
20 |     use with another object.&nbsp;&nbsp; It may be constructed either
21 |     directly or through an <a href="Allocator.html">Allocator</a>
22 |     object.<br>
23 |     <br>
24 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Param(std::string
25 |       Name, Type *Tp) : Value(Name, Tp), index_(-1) { }</b><b><br>
26 |     </b><br>
27 |   </body>
28 | </html>
29 | 


--------------------------------------------------------------------------------
/docs/Property.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Property</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Property<br>
 9 |       </font>
10 |       <div align="left">A Property is similar to a <a href="Field.html">Field.</a>&nbsp;
11 | 
12 |         However, instead of holding a place to store data, it holds
13 |         functions that are used to set and retrieve the
14 |         data.&nbsp;&nbsp; This way, some operation may be performed on
15 |         the data before it is stored or retrieved, or multiple data
16 |         fields may be kept in sync automatically simply by referencing
17 |         the property.&nbsp;&nbsp; A property is always a member of a
18 |         class; it may not be stored directly in an assembly.<br>
19 |         <br>
20 |         While properties can have variably long argument lists which can
21 |         be used to 'index' the property, the normal case is that the
22 |         function which 'gets' the value takes no arguments and returns a
23 |         value of the appropriate type.&nbsp;&nbsp; The function which
24 |         'sets' the value takes one argument, which is the value to set.<br>
25 |         <br>
26 |         Generally, once a property is defined it can be treated like a
27 |         field, except that instead of using LDFLD/LDSFLD STFLD/STSFLD to
28 |         store and load the data, one would call the appropriate getter
29 |         or setter.&nbsp;&nbsp; The Property object will create these
30 |         calls, and has functions for generating the call instructions.<br>
31 |         <br>
32 |         <br>
33 |         The Property object may be constructed either directly or
34 |         through an <a href="Allocator.html">Allocator</a>
35 |         object.&nbsp;&nbsp; In the normal case one would pass an empty
36 |         vector for the 'indices' parameter.<br>
37 |         <br>
38 |         &nbsp;<b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Property(PELib
39 |           &amp;peLib, std::string name, Type *type, std::vector&lt;Type
40 |           *&gt;&amp; indices, bool hasSetter = true); </b><b><br>
41 |         </b><b><br>
42 |         </b>Set the parent container.&nbsp; Usually done automatically
43 |         when the Property is added to a class.<br>
44 |         <b><br>
45 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
46 |           SetContainer(DataContainer *parent, bool add = true);<br>
47 |           <br>
48 |         </b>Access whether or not this is a static property.<br>
49 |         <b></b><b><br>
50 |           &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void Instance(bool
51 |           instance);</b><b><br>
52 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool
53 |           Instance() const { return instance_;&nbsp; }<br>
54 |           <br>
55 |         </b>Get the property name.<br>
56 |         <br>
57 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const
58 |           std::string &amp;Name() const { return name_; }<br>
59 |         </b><br>
60 |         Access the type of the data the property represents<br>
61 |         <br>
62 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
63 |           SetType(Type *type) { type_ = type;&nbsp; }</b><b><br>
64 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type
65 |           *GetType() const { return type_;&nbsp; }<br>
66 |           <br>
67 |         </b>Call the property's getter.&nbsp;&nbsp; One should push the
68 |         class instance on the stack first if this is not a static
69 |         property.<br>
70 |         <br>
71 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void CallGet(PELib
72 |           &amp;peLib, CodeContainer *code);<br>
73 |           <br>
74 |         </b>Call the property's setter.&nbsp;&nbsp; One should
75 |         optionally push the class instance on the stack, then push the
76 |         data to be set<br>
77 |         <b></b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
78 |           CallSet(PELib &amp;peLib, CodeContainer *code);</b><b><br>
79 |         </b><b><br>
80 |         </b>Retrieve the getter or setter functions.&nbsp;&nbsp; When
81 |         creating a property this is necessary so that you can add code
82 |         to these functions.<br>
83 |         <br>
84 |         <b>&nbsp;</b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Method
85 |           *Getter() { return getter_;&nbsp; }</b><b><br>
86 |         </b><b>&nbsp;</b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Method
87 |           *Setter() { return setter_;&nbsp; }</b><b><br>
88 |         </b><b><br>
89 |         </b><b><br>
90 |         </b><b>&nbsp;</b><br>
91 |       </div>
92 |     </div>
93 |   </body>
94 | </html>
95 | 


--------------------------------------------------------------------------------
/docs/Qualifier.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Qualifier</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center">
 9 |       <div align="center"><font size="+3">Qualifier</font><br>
10 |       </div>
11 |       <div align="left"><br>
12 |       </div>
13 |     </div>
14 |     The Qualifier class holds standard qualifiers for CIL
15 |     objects.&nbsp;&nbsp; It is used by other objects to set the
16 |     environment in which CIL objects will be created.<br>
17 |     <br>
18 |     Here is a list of supported qualifiers:<br>
19 |     <br>
20 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
21 |     Public = 0x1,<br>
22 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
23 |     Private = 0x2,<br>
24 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
25 |     Static = 0x4,<br>
26 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
27 |     Instance = 0x8,<br>
28 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
29 |     Explicit = 0x10,<br>
30 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
31 |     Ansi = 0x20,<br>
32 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
33 |     Sealed = 0x40,<br>
34 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
35 |     Enum = 0x80,<br>
36 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
37 |     Value = 0x100,<br>
38 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
39 |     Sequential = 0x200,<br>
40 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
41 |     Auto = 0x400,<br>
42 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
43 |     Literal = 0x800,<br>
44 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
45 |     HideBySig = 0x1000,<br>
46 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
47 |     PreserveSig = 0x2000,<br>
48 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
49 |     SpecialName = 0x4000,<br>
50 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
51 |     RTSpecialName = 0x8000,<br>
52 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
53 |     CIL = 0x10000,<br>
54 |     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
55 |     Managed = 0x20000<br>
56 |     <br>
57 |     The qualifier objects usually aren't constructed but are kept as
58 |     direct members of other objects.&nbsp;&nbsp; They are often
59 |     specified in object constructors.<br>
60 |     <br>
61 |     <br>
62 |     GetName() is a function that creates the fully qualified ILASM name
63 |     for an entity.<br>
64 |     <br>
65 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; static std::string
66 |       GetName(std::string root, DataContainer *parent, bool type =
67 |       false);</b><b><br>
68 |     </b>&nbsp; <br>
69 |     Accessors for the actual flags held by this object<br>
70 |     <br>
71 |     <b>&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; int Flags() const { return
72 |       flags_; }</b><b><br>
73 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void Flags(int
74 |       flags) { flags_ = flags;&nbsp; }</b><b><br>
75 |     </b><br>
76 |   </body>
77 | </html>
78 | 


--------------------------------------------------------------------------------
/docs/SEH.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - SEH</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">SEH Blocks<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         SEH blocks are the .NET methodology for storying information about
12 |         try--catch or try--catch--finally sequences. (fault and filter are
13 |         also supported).   To support SEH, one makes region boundaries in the
14 |         method body.   Each region has a beginning and an ending, and regions may
15 |         be nested to allow for nesting of try--catch blocks.  A region boundary
16 |         is created with a special form of the <a href="Instruction.html">Instruction </a>
17 |         object constructor and added to a method.<br><br>
18 | 
19 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum iseh {</b><b><br>
20 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
21 | 
22 | 
23 |       seh_try,</b><b><br>
24 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
25 | 
26 | 
27 |       seh_catch,</b><b><br>
28 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
29 | 
30 | 
31 |       seh_filter,</b><b><br>
32 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
33 | 
34 | 
35 |       seh_fault,</b><b><br>
36 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
37 | 
38 | 
39 |       seh_finally,</b><b><br>
40 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; };</b><b><br>
41 |     </b><br>
42 | 
43 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instruction(iseh type, bool begin,
44 |           Type *catchType = nullptr);</b><b><br></b>
45 | 	<br>
46 |         where <b>catchType</b> only needs to be specified when the block type is seh_catch.
47 | 	Each region must have both a beginning and an ending.  For the beginning <b>begin</b>
48 |         is true, otherwise it is false.  In addition there must be a try block followed by at
49 |         least one of the other block types.   Note that the .net runtime does not always let
50 |         one chain multiple block types, for example a try--catch would look as follows<br><br>
51 | 
52 | 	<b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try begin</br>
53 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br>
54 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;leave ...<br>
55 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try end</br>
56 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch begin</br>
57 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br>
58 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;leave ...<br>
59 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch end</br>
60 | 	<br>
61 | 	</b>
62 | 	but a try--catch--finally would look as follows, to satisfy the runtime engine:<br>
63 | 	<br>
64 | 	<b>
65 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try begin</br>
66 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try begin</br>
67 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br>
68 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;leave...<br>
69 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try end</br>
70 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch begin</br>
71 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br>
72 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;leave...<br>
73 |             &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch end</br>
74 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;leave ...<br>
75 |         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try end</br>
76 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;finally begin</br>
77 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;...<br>
78 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;endfinally ...<br>
79 | 	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;finally end</br>
80 | 	</b>
81 | 	<br>
82 | 	In addition to the above, the rules for the epilogues must also be followed in each block
83 |         (for example use leave, or endfinally) and if it is a catch block you have to pop the caught
84 |         object.<br>
85 |         <br>
86 |       </div>
87 |     </div>
88 |   </body>
89 | </html>
90 | 


--------------------------------------------------------------------------------
/docs/Type.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  2 | <html>
  3 |   <head>
  4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  5 |     <title>DotNetPELib - Type</title>
  6 |   </head>
  7 |   <body>
  8 |     <div align="center"><font size="+3">Type<br>
  9 |       </font>
 10 |       <div align="left"><br>
 11 |       </div>
 12 |     </div>
 13 |     A Type is used in various places to qualify an entity, for example
 14 |     it can hold the underlying type of a <a href="Field.html">Field</a>
 15 |     or <a href="Local.html">Local</a>, or the return type or <a
 16 |       href="Param.html">Param</a> types for <a
 17 |       href="MethodSignature.html">MethodSignatures</a>.<br>
 18 |     <br>
 19 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum BasicType {</b><b><br>
 20 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 21 | 
 22 | 
 23 |       ///** type is a reference to a class</b><b><br>
 24 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 25 | 
 26 | 
 27 |       cls,</b><b><br>
 28 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 29 | 
 30 | 
 31 |       ///** type is a reference to a method signature</b><b><br>
 32 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 33 | 
 34 | 
 35 |       method,</b><b><br>
 36 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 37 | 
 38 | 
 39 |       /* below this is various CIL types*/</b><b><br>
 40 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 41 | 
 42 | 
 43 |       Void, Bool, Char, i8, u8, i16, u16, i32, u32, i64, u64, inative,
 44 |       unative, r32, r64, object, string</b><b><br>
 45 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; };</b><b><br>
 46 |     </b><br>
 47 |     Closely related to Type is <a href="BoxedType.html">BoxedType</a>,
 48 |     which represents the boxed version of basic CIL types.<br>
 49 |     <br>
 50 |     A type may be constructed either directly or through an <a
 51 |       href="Allocator.html">Allocator</a> object.&nbsp;&nbsp; Choose one
 52 |     of several constructors depending on the type being
 53 |     constructed.&nbsp;&nbsp; Additionally, a qualifying function may
 54 |     have to be called for example if the type is an array type.<br>
 55 |     <br>
 56 |     Constructor for a basic type, e.g. integers, floats, strings, and
 57 |     the base object type.<br>
 58 |     <br>
 59 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type(BasicType Tp, int
 60 |       PointerLevel) ;</b><b><br>
 61 |     </b><br>
 62 |     Constructor for a value of type Class<br>
 63 |     <b><br>
 64 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type(DataContainer
 65 |       *clsref) ;<br>
 66 |       <br>
 67 |     </b>Constructor for a method pointer<br>
 68 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type(MethodSignature
 69 |       *methodref) ;<br>
 70 |       <br>
 71 |     </b>Access the basic type<br>
 72 |     <br>
 73 |     <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; enum BasicType
 74 |       GetBasicType() const { return tp_; }</b><b><br>
 75 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
 76 |       SetBasicType(BasicType type) { tp_ = type; }<br>
 77 |       <br>
 78 |     </b>Access extended types<br>
 79 |     <b></b><b><br>
 80 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DataContainer
 81 |       *GetClass() const { return typeRef_; }</b><b><br>
 82 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MethodSignature
 83 |       *GetMethod() const { return methodRef_; }</b><b><br>
 84 |     </b><b>&nbsp;<br>
 85 |     </b>Access the array rank (note - arrays of &gt; 1 dimension require
 86 |     use of CIL intrinsics that aren't directly supported by
 87 |     DotNetPELib....&nbsp;&nbsp; occil implements them as an addon
 88 |     though)<br>
 89 |     <b></b><b><br>
 90 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void ArrayLevel(int
 91 |       arrayLevel) { arrayLevel_ = arrayLevel;&nbsp; }</b><b><br>
 92 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int ArrayLevel()
 93 |       const { return arrayLevel_;&nbsp; }</b><b><br>
 94 |     </b><b><br>
 95 |     </b>Access the number of pointer qualifers<br>
 96 |     <b><br>
 97 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void PointerLevel(int
 98 |       n) { pointerLevel_ = n; }</b><b><br>
 99 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int PointerLevel()
100 |       const { return pointerLevel_; }</b><b><br>
101 |     </b><b><br>
102 |     </b>Access the ByRef flag.<br>
103 |     <b><br>
104 |       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void ByRef(bool val) {
105 |       byRef_ = val; }</b><b><br>
106 |     </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool ByRef() {
107 |       return byRef_; }</b><b><br>
108 |     </b><br>
109 |   </body>
110 | </html>
111 | 


--------------------------------------------------------------------------------
/docs/Value.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 2 | <html>
 3 |   <head>
 4 |     <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 5 |     <title>DotNetPELib - Value</title>
 6 |   </head>
 7 |   <body>
 8 |     <div align="center"><font size="+3">Value<br>
 9 |       </font>
10 |       <div align="left"><br>
11 |         A Value is the base type for various types of <a
12 |           href="Operand.html">Operand</a> values, to be used in<a
13 |           href="Instruction.html"> Instructions</a>.&nbsp;&nbsp; Some
14 |         things inherited from Value are aditionally used to define <a
15 |           href="Local.html">Local</a> variables and Method <a
16 |           href="Param.html">Params.</a><br>
17 |         <br>
18 |         Sometimes, the Value object is used directly to denote an
19 |         Operand which is the name of a type.<br>
20 |         <br>
21 |         <br>
22 |         The following are derived from Value:<br>
23 |         <br>
24 |         <a href="Local.html">Local</a><br>
25 |         <a href="Param.html">Param</a><br>
26 |         <a href="FieldName.html">FieldName</a><br>
27 |         <a href="MethodName.html">MethodName</a><br>
28 |         <br>
29 |         Value objects may be directly constructed, or constructed
30 |         through an <a href="Allocator.html">Allocator</a> object.<br>
31 |         <br>
32 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Value(std::string
33 |           Name, Type *tp) : name_(Name), type_(tp) { }</b><b><br>
34 |         </b><br>
35 |         Access type<br>
36 |         <br>
37 |         <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Type *GetType()
38 |           const { return type_; }</b><b><br>
39 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
40 |           SetType(Type *tp) { type_ = tp; }</b><b><br>
41 |         </b><br>
42 |         Access name<br>
43 |         <br>
44 |         &nbsp;<b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const std::string
45 |           &amp;Name() const { return name_; }</b><b><br>
46 |         </b><b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void
47 |           Name(const std::string name) { name_ = name; }</b><b><br>
48 |         </b><br>
49 |       </div>
50 |     </div>
51 |   </body>
52 | </html>
53 | 


--------------------------------------------------------------------------------
/libhostfxr/_version.h:
--------------------------------------------------------------------------------
 1 | #ifndef VER_COMPANYNAME_STR
 2 | #define VER_COMPANYNAME_STR         ".NET Foundation"
 3 | #endif
 4 | #ifndef VER_FILEDESCRIPTION_STR
 5 | #define VER_FILEDESCRIPTION_STR     ".NET Runtime"
 6 | #endif
 7 | #ifndef VER_INTERNALNAME_STR
 8 | #define VER_INTERNALNAME_STR        VER_FILEDESCRIPTION_STR
 9 | #endif
10 | #ifndef VER_ORIGINALFILENAME_STR
11 | #define VER_ORIGINALFILENAME_STR    VER_FILEDESCRIPTION_STR
12 | #endif
13 | #ifndef VER_PRODUCTNAME_STR
14 | #define VER_PRODUCTNAME_STR         ".NET"
15 | #endif
16 | #undef VER_PRODUCTVERSION
17 | #define VER_PRODUCTVERSION          00,00,00,00000
18 | #undef VER_PRODUCTVERSION_STR
19 | #define VER_PRODUCTVERSION_STR      "0.0.0"
20 | #undef VER_FILEVERSION
21 | #define VER_FILEVERSION             00,00,00,00000
22 | #undef VER_FILEVERSION_STR
23 | #define VER_FILEVERSION_STR         "00,00,00,00000"
24 | #ifndef VER_LEGALCOPYRIGHT_STR
25 | #define VER_LEGALCOPYRIGHT_STR      ".NET Foundation"
26 | #endif
27 | #ifndef VER_DEBUG
28 | #define VER_DEBUG                   VS_FF_DEBUG
29 | #endif
30 | 


--------------------------------------------------------------------------------
/libhostfxr/error_codes.h:
--------------------------------------------------------------------------------
 1 | // Licensed to the .NET Foundation under one or more agreements.
 2 | // The .NET Foundation licenses this file to you under the MIT license.
 3 | 
 4 | #ifndef __ERROR_CODES_H__
 5 | #define __ERROR_CODES_H__
 6 | 
 7 | // These error and exit codes are document in the host-error-codes.md
 8 | enum StatusCode
 9 | {
10 |     // Success
11 |     Success                             = 0,
12 |     Success_HostAlreadyInitialized      = 0x00000001,
13 |     Success_DifferentRuntimeProperties  = 0x00000002,
14 | 
15 |     // Failure
16 |     InvalidArgFailure                   = 0x80008081,
17 |     CoreHostLibLoadFailure              = 0x80008082,
18 |     CoreHostLibMissingFailure           = 0x80008083,
19 |     CoreHostEntryPointFailure           = 0x80008084,
20 |     CoreHostCurHostFindFailure          = 0x80008085,
21 |     // unused                           = 0x80008086,
22 |     CoreClrResolveFailure               = 0x80008087,
23 |     CoreClrBindFailure                  = 0x80008088,
24 |     CoreClrInitFailure                  = 0x80008089,
25 |     CoreClrExeFailure                   = 0x8000808a,
26 |     ResolverInitFailure                 = 0x8000808b,
27 |     ResolverResolveFailure              = 0x8000808c,
28 |     LibHostCurExeFindFailure            = 0x8000808d,
29 |     LibHostInitFailure                  = 0x8000808e,
30 |     // unused                           = 0x8000808f,
31 |     LibHostExecModeFailure              = 0x80008090,
32 |     LibHostSdkFindFailure               = 0x80008091,
33 |     LibHostInvalidArgs                  = 0x80008092,
34 |     InvalidConfigFile                   = 0x80008093,
35 |     AppArgNotRunnable                   = 0x80008094,
36 |     AppHostExeNotBoundFailure           = 0x80008095,
37 |     FrameworkMissingFailure             = 0x80008096,
38 |     HostApiFailed                       = 0x80008097,
39 |     HostApiBufferTooSmall               = 0x80008098,
40 |     LibHostUnknownCommand               = 0x80008099,
41 |     LibHostAppRootFindFailure           = 0x8000809a,
42 |     SdkResolverResolveFailure           = 0x8000809b,
43 |     FrameworkCompatFailure              = 0x8000809c,
44 |     FrameworkCompatRetry                = 0x8000809d,
45 |     // unused                           = 0x8000809e,
46 |     BundleExtractionFailure             = 0x8000809f,
47 |     BundleExtractionIOError             = 0x800080a0,
48 |     LibHostDuplicateProperty            = 0x800080a1,
49 |     HostApiUnsupportedVersion           = 0x800080a2,
50 |     HostInvalidState                    = 0x800080a3,
51 |     HostPropertyNotFound                = 0x800080a4,
52 |     CoreHostIncompatibleConfig          = 0x800080a5,
53 |     HostApiUnsupportedScenario          = 0x800080a6,
54 |     HostFeatureDisabled                 = 0x800080a7,
55 | };
56 | 
57 | #define STATUS_CODE_SUCCEEDED(status_code) ((static_cast<int>(static_cast<StatusCode>(status_code))) >= 0)
58 | 
59 | #endif // __ERROR_CODES_H__
60 | 


--------------------------------------------------------------------------------
/libhostfxr/fx_ver.h:
--------------------------------------------------------------------------------
 1 | // Licensed to the .NET Foundation under one or more agreements.
 2 | // The .NET Foundation licenses this file to you under the MIT license.
 3 | 
 4 | #ifndef __FX_VER_H__
 5 | #define __FX_VER_H__
 6 | 
 7 | #include <pal.h>
 8 | 
 9 | // Note: This is intended to implement SemVer 2.0
10 | struct fx_ver_t
11 | {
12 |     fx_ver_t();
13 |     fx_ver_t(int major, int minor, int patch);
14 |     // if not empty pre contains valid prerelease label with leading '-'
15 |     fx_ver_t(int major, int minor, int patch, const pal::string_t& pre);
16 |     // if not empty pre contains valid prerelease label with leading '-'
17 |     // if not empty build contains valid build label with leading '+'
18 |     fx_ver_t(int major, int minor, int patch, const pal::string_t& pre, const pal::string_t& build);
19 | 
20 |     int get_major() const { return m_major; }
21 |     int get_minor() const { return m_minor; }
22 |     int get_patch() const { return m_patch; }
23 | 
24 |     bool is_prerelease() const { return !m_pre.empty(); }
25 | 
26 |     bool is_empty() const { return m_major == -1; }
27 | 
28 |     pal::string_t as_str() const;
29 | 
30 |     bool operator ==(const fx_ver_t& b) const;
31 |     bool operator !=(const fx_ver_t& b) const;
32 |     bool operator <(const fx_ver_t& b) const;
33 |     bool operator >(const fx_ver_t& b) const;
34 |     bool operator <=(const fx_ver_t& b) const;
35 |     bool operator >=(const fx_ver_t& b) const;
36 | 
37 |     static bool parse(const pal::string_t& ver, fx_ver_t* fx_ver, bool parse_only_production = false);
38 | 
39 | private:
40 |     int m_major;
41 |     int m_minor;
42 |     int m_patch;
43 |     pal::string_t m_pre;
44 |     pal::string_t m_build;
45 | 
46 |     static int compare(const fx_ver_t&a, const fx_ver_t& b);
47 | };
48 | 
49 | #endif // __FX_VER_H__
50 | 


--------------------------------------------------------------------------------
/libhostfxr/fxr_resolver.cpp:
--------------------------------------------------------------------------------
  1 | // Licensed to the .NET Foundation under one or more agreements.
  2 | // The .NET Foundation licenses this file to you under the MIT license.
  3 | 
  4 | #include "pal.h"
  5 | #include "fxr_resolver.h"
  6 | #include "fx_ver.h"
  7 | #include "trace.h"
  8 | #include "fxrutils.h"
  9 | 
 10 | namespace
 11 | {
 12 |     bool get_latest_fxr(pal::string_t fxr_root, pal::string_t* out_fxr_path)
 13 |     {
 14 |         trace::info(_X("Reading fx resolver directory=[%s]"), fxr_root.c_str());
 15 | 
 16 |         std::vector<pal::string_t> list;
 17 |         pal::readdir_onlydirectories(fxr_root, &list);
 18 | 
 19 |         fx_ver_t max_ver;
 20 |         for (const auto& dir : list)
 21 |         {
 22 |             trace::info(_X("Considering fxr version=[%s]..."), dir.c_str());
 23 | 
 24 |             pal::string_t ver = get_filename(dir);
 25 | 
 26 |             fx_ver_t fx_ver;
 27 |             if (fx_ver_t::parse(ver, &fx_ver, /* parse_only_production */ false))
 28 |             {
 29 |                 max_ver = std::max(max_ver, fx_ver);
 30 |             }
 31 |         }
 32 | 
 33 |         if (max_ver == fx_ver_t())
 34 |         {
 35 |             trace::error(_X("Error: [%s] does not contain any version-numbered child folders"), fxr_root.c_str());
 36 |             return false;
 37 |         }
 38 | 
 39 |         pal::string_t max_ver_str = max_ver.as_str();
 40 |         append_path(&fxr_root, max_ver_str.c_str());
 41 |         trace::info(_X("Detected latest fxr version=[%s]..."), fxr_root.c_str());
 42 | 
 43 |         if (file_exists_in_dir(fxr_root, LIBFXR_NAME, out_fxr_path))
 44 |         {
 45 |             trace::info(_X("Resolved fxr [%s]..."), out_fxr_path->c_str());
 46 |             return true;
 47 |         }
 48 | 
 49 |         trace::error(_X("Error: the required library %s could not be found in [%s]"), LIBFXR_NAME, fxr_root.c_str());
 50 | 
 51 |         return false;
 52 |     }
 53 | }
 54 | 
 55 | bool fxr_resolver::try_get_path(const pal::string_t& root_path, pal::string_t* out_dotnet_root, pal::string_t* out_fxr_path)
 56 | {
 57 | #if defined(FEATURE_APPHOST) || defined(FEATURE_LIBHOST)
 58 |     // For apphost and libhost, root_path is expected to be a directory.
 59 |     // For libhost, it may be empty if app-local search is not desired (e.g. com/ijw/winrt hosts, nethost when no assembly path is specified)
 60 |     // If a hostfxr exists in root_path, then assume self-contained.
 61 |     if (root_path.length() > 0 && file_exists_in_dir(root_path, LIBFXR_NAME, out_fxr_path))
 62 |     {
 63 |         trace::info(_X("Resolved fxr [%s]..."), out_fxr_path->c_str());
 64 |         out_dotnet_root->assign(root_path);
 65 |         return true;
 66 |     }
 67 | 
 68 |     // For framework-dependent apps, use DOTNET_ROOT_<ARCH>
 69 |     pal::string_t default_install_location;
 70 |     pal::string_t dotnet_root_env_var_name;
 71 |     if (get_dotnet_root_from_env(&dotnet_root_env_var_name, out_dotnet_root))
 72 |     {
 73 |         trace::info(_X("Using environment variable %s=[%s] as runtime location."), dotnet_root_env_var_name.c_str(), out_dotnet_root->c_str());
 74 |     }
 75 |     else
 76 |     {
 77 |         if (pal::get_dotnet_self_registered_dir(&default_install_location) || pal::get_default_installation_dir(&default_install_location))
 78 |         {
 79 |             trace::info(_X("Using global installation location [%s] as runtime location."), default_install_location.c_str());
 80 |             out_dotnet_root->assign(default_install_location);
 81 |         }
 82 |         else
 83 |         {
 84 |             trace::error(_X("Error: the default install location cannot be obtained."));
 85 |             return false;
 86 |         }
 87 |     }
 88 | 
 89 |     pal::string_t fxr_dir = *out_dotnet_root;
 90 |     append_path(&fxr_dir, _X("host"));
 91 |     append_path(&fxr_dir, _X("fxr"));
 92 |     if (!pal::directory_exists(fxr_dir))
 93 |     {
 94 |         if (default_install_location.empty())
 95 |         {
 96 |             pal::get_dotnet_self_registered_dir(&default_install_location);
 97 |         }
 98 |         if (default_install_location.empty())
 99 |         {
100 |             pal::get_default_installation_dir(&default_install_location);
101 |         }
102 | 
103 |         pal::string_t self_registered_config_location = pal::get_dotnet_self_registered_config_location(get_current_arch());
104 |         trace::verbose(_X("The required library %s could not be found. Searched with root path [%s], environment variable [%s], default install location [%s], self-registered config location [%s]"),
105 |             LIBFXR_NAME,
106 |             root_path.c_str(),
107 |             dotnet_root_env_var_name.c_str(),
108 |             default_install_location.c_str(),
109 |             self_registered_config_location.c_str());
110 | 
111 |         pal::string_t host_path;
112 |         pal::get_own_executable_path(&host_path);
113 |         trace::error(
114 |             MISSING_RUNTIME_ERROR_FORMAT,
115 |             INSTALL_NET_ERROR_MESSAGE,
116 |             host_path.c_str(),
117 |             get_current_arch_name(),
118 |             _STRINGIFY(HOST_VERSION),
119 |             _X("Not found"),
120 |             get_download_url().c_str(),
121 |             _STRINGIFY(HOST_VERSION));
122 |         return false;
123 |     }
124 | 
125 |     return get_latest_fxr(std::move(fxr_dir), out_fxr_path);
126 | #else // !FEATURE_APPHOST && !FEATURE_LIBHOST
127 |     // For non-apphost and non-libhost (i.e. muxer), root_path is expected to be the full path to the host
128 |     pal::string_t host_dir;
129 |     host_dir.assign(get_directory(root_path));
130 | 
131 |     out_dotnet_root->assign(host_dir);
132 | 
133 |     return fxr_resolver::try_get_path_from_dotnet_root(*out_dotnet_root, out_fxr_path);
134 | #endif // !FEATURE_APPHOST && !FEATURE_LIBHOST
135 | }
136 | 
137 | bool fxr_resolver::try_get_path_from_dotnet_root(const pal::string_t& dotnet_root, pal::string_t* out_fxr_path)
138 | {
139 |     pal::string_t fxr_dir = dotnet_root;
140 |     append_path(&fxr_dir, _X("host"));
141 |     append_path(&fxr_dir, _X("fxr"));
142 |     if (!pal::directory_exists(fxr_dir))
143 |     {
144 |         trace::error(_X("Error: [%s] does not exist"), fxr_dir.c_str());
145 |         return false;
146 |     }
147 | 
148 |     return get_latest_fxr(std::move(fxr_dir), out_fxr_path);
149 | }
150 | 
151 | bool fxr_resolver::try_get_existing_fxr(pal::dll_t* out_fxr, pal::string_t* out_fxr_path)
152 | {
153 |     if (!pal::get_loaded_library(LIBFXR_NAME, "hostfxr_main", out_fxr, out_fxr_path))
154 |         return false;
155 | 
156 |     trace::verbose(_X("Found previously loaded library %s [%s]."), LIBFXR_NAME, out_fxr_path->c_str());
157 |     return true;
158 | }
159 | 


--------------------------------------------------------------------------------
/libhostfxr/fxr_resolver.h:
--------------------------------------------------------------------------------
  1 | // Licensed to the .NET Foundation under one or more agreements.
  2 | // The .NET Foundation licenses this file to you under the MIT license.
  3 | 
  4 | #ifndef _COREHOST_CLI_FXR_RESOLVER_H_
  5 | #define _COREHOST_CLI_FXR_RESOLVER_H_
  6 | 
  7 | #include "pal.h"
  8 | #include "hostfxr.h"
  9 | #include "trace.h"
 10 | #include "fxrutils.h"
 11 | #include "error_codes.h"
 12 | 
 13 | namespace fxr_resolver
 14 | {
 15 |     bool try_get_path(const pal::string_t& root_path, pal::string_t* out_dotnet_root, pal::string_t* out_fxr_path);
 16 |     bool try_get_path_from_dotnet_root(const pal::string_t& dotnet_root, pal::string_t* out_fxr_path);
 17 |     bool try_get_existing_fxr(pal::dll_t *out_fxr, pal::string_t *out_fxr_path);
 18 | }
 19 | 
 20 | template<typename THostPathToConfigCallback, typename TBeforeRunCallback>
 21 | int load_fxr_and_get_delegate(hostfxr_delegate_type type, THostPathToConfigCallback host_path_to_config_path, TBeforeRunCallback on_before_run, void** delegate, bool try_ignore_missing_config)
 22 | {
 23 |     pal::dll_t fxr;
 24 | 
 25 |     pal::string_t host_path;
 26 |     if (!pal::get_own_module_path(&host_path) || !pal::realpath(&host_path))
 27 |     {
 28 |         trace::error(_X("Failed to resolve full path of the current host module [%s]"), host_path.c_str());
 29 |         return StatusCode::CoreHostCurHostFindFailure;
 30 |     }
 31 | 
 32 |     pal::string_t dotnet_root;
 33 |     pal::string_t fxr_path;
 34 |     if (fxr_resolver::try_get_existing_fxr(&fxr, &fxr_path))
 35 |     {
 36 |         dotnet_root = get_dotnet_root_from_fxr_path(fxr_path);
 37 |         trace::verbose(_X("The library %s was already loaded. Reusing the previously loaded library [%s]."), LIBFXR_NAME, fxr_path.c_str());
 38 |     }
 39 |     else
 40 |     {
 41 |         // Do not specify the root path. Getting a delegate does not support self-contained (app-local fxr)
 42 |         if (!fxr_resolver::try_get_path(pal::string_t{}, &dotnet_root, &fxr_path))
 43 |         {
 44 |             return StatusCode::CoreHostLibMissingFailure;
 45 |         }
 46 | 
 47 |         // Load library
 48 |         if (!pal::load_library(&fxr_path, &fxr))
 49 |         {
 50 |             trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str());
 51 |             trace::error(_X("  - Installing .NET prerequisites might help resolve this problem."));
 52 |             trace::error(_X("     %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL);
 53 |             return StatusCode::CoreHostLibLoadFailure;
 54 |         }
 55 |     }
 56 | 
 57 |     // Leak fxr
 58 | 
 59 |     auto hostfxr_initialize_for_runtime_config = reinterpret_cast<hostfxr_initialize_for_runtime_config_fn>(pal::get_symbol(fxr, "hostfxr_initialize_for_runtime_config"));
 60 |     auto hostfxr_get_runtime_delegate = reinterpret_cast<hostfxr_get_runtime_delegate_fn>(pal::get_symbol(fxr, "hostfxr_get_runtime_delegate"));
 61 |     auto hostfxr_close = reinterpret_cast<hostfxr_close_fn>(pal::get_symbol(fxr, "hostfxr_close"));
 62 |     if (hostfxr_initialize_for_runtime_config == nullptr || hostfxr_get_runtime_delegate == nullptr || hostfxr_close == nullptr)
 63 |         return StatusCode::CoreHostEntryPointFailure;
 64 | 
 65 |     pal::string_t config_path;
 66 |     pal::hresult_t status = host_path_to_config_path(host_path, &config_path);
 67 |     if (status != StatusCode::Success)
 68 |         return status;
 69 | 
 70 |     hostfxr_set_error_writer_fn set_error_writer_fn = reinterpret_cast<hostfxr_set_error_writer_fn>(pal::get_symbol(fxr, "hostfxr_set_error_writer"));
 71 |     {
 72 |         propagate_error_writer_t propagate_error_writer_to_hostfxr(set_error_writer_fn);
 73 |         if (!try_ignore_missing_config || pal::file_exists(config_path))
 74 |         {
 75 |             hostfxr_initialize_parameters parameters {
 76 |                 sizeof(hostfxr_initialize_parameters),
 77 |                 host_path.c_str(),
 78 |                 dotnet_root.c_str()
 79 |             };
 80 | 
 81 |             hostfxr_handle context;
 82 |             int rc = hostfxr_initialize_for_runtime_config(config_path.c_str(), &parameters, &context);
 83 |             if (!STATUS_CODE_SUCCEEDED(rc))
 84 |                 return rc;
 85 | 
 86 |             on_before_run(fxr, context);
 87 | 
 88 |             rc = hostfxr_get_runtime_delegate(context, type, delegate);
 89 | 
 90 |             int rcClose = hostfxr_close(context);
 91 |             if (rcClose != StatusCode::Success)
 92 |             {
 93 |                 assert(false && "Failed to close host context");
 94 |                 trace::verbose(_X("Failed to close host context: 0x%x"), rcClose);
 95 |             }
 96 | 
 97 |             return rc;
 98 |         }
 99 |         else
100 |         {
101 |             // null context means use the current one, if none exists it will fail
102 |             int rc = hostfxr_get_runtime_delegate(nullptr, type, delegate);
103 |             if (rc == StatusCode::HostInvalidState)
104 |             {
105 |                 trace::error(_X("Expected active runtime context because runtimeconfig.json [%s] does not exist."), config_path.c_str());
106 |             }
107 |             return rc;
108 |         }
109 |     }
110 | }
111 | 
112 | #endif //_COREHOST_CLI_FXR_RESOLVER_H_
113 | 


--------------------------------------------------------------------------------
/libhostfxr/libhostfxr.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClInclude Include="error_codes.h">
19 |       <Filter>Header Files</Filter>
20 |     </ClInclude>
21 |     <ClInclude Include="fxr_resolver.h">
22 |       <Filter>Header Files</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="hostfxr.h">
25 |       <Filter>Header Files</Filter>
26 |     </ClInclude>
27 |     <ClInclude Include="pal.h">
28 |       <Filter>Header Files</Filter>
29 |     </ClInclude>
30 |     <ClInclude Include="longfile.h">
31 |       <Filter>Header Files</Filter>
32 |     </ClInclude>
33 |     <ClInclude Include="fx_ver.h">
34 |       <Filter>Header Files</Filter>
35 |     </ClInclude>
36 |     <ClInclude Include="runtime_version.h">
37 |       <Filter>Header Files</Filter>
38 |     </ClInclude>
39 |     <ClInclude Include="fxrutils.h">
40 |       <Filter>Header Files</Filter>
41 |     </ClInclude>
42 |     <ClInclude Include="_version.h">
43 |       <Filter>Header Files</Filter>
44 |     </ClInclude>
45 |   </ItemGroup>
46 |   <ItemGroup>
47 |     <ClCompile Include="fxr_resolver.cpp">
48 |       <Filter>Source Files</Filter>
49 |     </ClCompile>
50 |     <ClCompile Include="pal.windows.cpp">
51 |       <Filter>Source Files</Filter>
52 |     </ClCompile>
53 |     <ClCompile Include="trace.cpp">
54 |       <Filter>Source Files</Filter>
55 |     </ClCompile>
56 |     <ClCompile Include="longfile.windows.cpp">
57 |       <Filter>Source Files</Filter>
58 |     </ClCompile>
59 |     <ClCompile Include="fx_ver.cpp">
60 |       <Filter>Source Files</Filter>
61 |     </ClCompile>
62 |     <ClCompile Include="fxrutils.cpp">
63 |       <Filter>Source Files</Filter>
64 |     </ClCompile>
65 |   </ItemGroup>
66 | </Project>


--------------------------------------------------------------------------------
/libhostfxr/longfile.h:
--------------------------------------------------------------------------------
 1 | // Licensed to the .NET Foundation under one or more agreements.
 2 | // The .NET Foundation licenses this file to you under the MIT license.
 3 | 
 4 | #ifndef _LONG_FILE_SUPPORT
 5 | #define _LONG_FILE_SUPPORT
 6 | 
 7 | class LongFile
 8 | {
 9 | public:
10 |     static const pal::string_t ExtendedPrefix;
11 |     static const pal::string_t DevicePathPrefix;
12 |     static const pal::string_t UNCPathPrefix;
13 |     static const pal::string_t UNCExtendedPathPrefix;
14 |     static const pal::char_t VolumeSeparatorChar;
15 |     static const pal::char_t DirectorySeparatorChar;
16 |     static const pal::char_t AltDirectorySeparatorChar;
17 | public:
18 |     static bool IsExtended(const pal::string_t& path);
19 |     static bool IsUNCExtended(const pal::string_t& path);
20 |     static bool ContainsDirectorySeparator(const pal::string_t & path);
21 |     static bool IsDirectorySeparator(const pal::char_t c);
22 |     static bool IsPathNotFullyQualified(const pal::string_t& path);
23 |     static bool IsDevice(const pal::string_t& path);
24 |     static bool IsNormalized(const pal::string_t& path);
25 |     static bool ShouldNormalize(const pal::string_t& path);
26 | };
27 | #endif //_LONG_FILE_SUPPORT
28 | 


--------------------------------------------------------------------------------
/libhostfxr/longfile.windows.cpp:
--------------------------------------------------------------------------------
  1 | // Licensed to the .NET Foundation under one or more agreements.
  2 | // The .NET Foundation licenses this file to you under the MIT license.
  3 | 
  4 | //The logic in this file was ported from https://github.com/dotnet/runtime/blob/17154bd7b8f21d6d8d6fca71b89d7dcb705ec32b/src/coreclr/utilcode/longfilepathwrappers.cpp
  5 | //Please reflect any change here into the above file too!
  6 | #include "pal.h"
  7 | #include "trace.h"
  8 | #include "fxrutils.h"
  9 | #include "longfile.h"
 10 | 
 11 | const pal::char_t LongFile::DirectorySeparatorChar = _X('\\');
 12 | const pal::char_t LongFile::AltDirectorySeparatorChar = _X('/');
 13 | const pal::char_t LongFile::VolumeSeparatorChar = _X(':');
 14 | const pal::string_t LongFile::ExtendedPrefix = _X("\\\\?\\");
 15 | const pal::string_t LongFile::DevicePathPrefix = _X("\\\\.\\");
 16 | const pal::string_t LongFile::UNCExtendedPathPrefix = _X("\\\\?\\UNC\\");
 17 | const pal::string_t LongFile::UNCPathPrefix = _X("\\\\");
 18 | 
 19 | bool LongFile::IsNormalized(const pal::string_t& path)
 20 | {
 21 |     return path.empty() || LongFile::IsDevice(path) || LongFile::IsExtended(path) || LongFile::IsUNCExtended(path);
 22 | }
 23 | bool ShouldNormalizeWorker(const pal::string_t& path)
 24 | {
 25 |     if (LongFile::IsNormalized(path))
 26 |         return false;
 27 | 
 28 |     if (!LongFile::IsPathNotFullyQualified(path) && path.size() < MAX_PATH)
 29 |         return false;
 30 | 
 31 |     return true;
 32 | }
 33 | 
 34 | //For longpath names on windows, if the paths are normalized they are always prefixed with
 35 | //extended syntax, Windows does not do any more normalizations on this string and uses it as is
 36 | //So we should ensure that there are NO adjacent DirectorySeparatorChar
 37 | bool AssertRepeatingDirSeparator(const pal::string_t& path)
 38 | {
 39 |     if (path.empty())
 40 |         return true;
 41 | 
 42 |     pal::string_t path_to_check = path;
 43 |     if (LongFile::IsDevice(path))
 44 |     {
 45 |         path_to_check.erase(0, LongFile::DevicePathPrefix.length());
 46 |     }
 47 |     else if (LongFile::IsExtended(path))
 48 |     {
 49 |         path_to_check.erase(0, LongFile::ExtendedPrefix.length());
 50 |     }
 51 |     else if (LongFile::IsUNCExtended(path))
 52 |     {
 53 |         path_to_check.erase(0, LongFile::UNCExtendedPathPrefix.length());
 54 |     }
 55 |     else if (path_to_check.compare(0, LongFile::UNCPathPrefix.length(), LongFile::UNCPathPrefix) == 0)
 56 |     {
 57 |         path_to_check.erase(0, LongFile::UNCPathPrefix.length());
 58 |     }
 59 | 
 60 |     pal::string_t dirSeparator;
 61 |     dirSeparator.push_back(LongFile::DirectorySeparatorChar);
 62 |     dirSeparator.push_back(LongFile::DirectorySeparatorChar);
 63 | 
 64 |     assert(path_to_check.find(dirSeparator) == pal::string_t::npos);
 65 | 
 66 |     pal::string_t altDirSeparator;
 67 |     altDirSeparator.push_back(LongFile::AltDirectorySeparatorChar);
 68 |     altDirSeparator.push_back(LongFile::AltDirectorySeparatorChar);
 69 | 
 70 |     assert(path_to_check.find(altDirSeparator) == pal::string_t::npos);
 71 | 
 72 |     pal::string_t combDirSeparator1;
 73 |     combDirSeparator1.push_back(LongFile::DirectorySeparatorChar);
 74 |     combDirSeparator1.push_back(LongFile::AltDirectorySeparatorChar);
 75 | 
 76 |     assert(path_to_check.find(combDirSeparator1) == pal::string_t::npos);
 77 | 
 78 |     pal::string_t combDirSeparator2;
 79 |     combDirSeparator2.push_back(LongFile::AltDirectorySeparatorChar);
 80 |     combDirSeparator2.push_back(LongFile::DirectorySeparatorChar);
 81 | 
 82 |     assert(path_to_check.find(combDirSeparator2) == pal::string_t::npos);
 83 | 
 84 |     assert(path_to_check.find(_X("..")) == pal::string_t::npos);
 85 |     return true;
 86 | }
 87 | bool  LongFile::ShouldNormalize(const pal::string_t& path)
 88 | {
 89 |     bool retval = ShouldNormalizeWorker(path);
 90 |     assert(retval || AssertRepeatingDirSeparator(path));
 91 |     return retval;
 92 | }
 93 | 
 94 | bool LongFile::IsExtended(const pal::string_t& path)
 95 | {
 96 |     return path.compare(0, ExtendedPrefix.length(), ExtendedPrefix) == 0;
 97 | }
 98 | 
 99 | bool LongFile::IsUNCExtended(const pal::string_t& path)
100 | {
101 |     return path.compare(0, UNCExtendedPathPrefix.length(), UNCExtendedPathPrefix) == 0;
102 | }
103 | 
104 | bool LongFile::IsDevice(const pal::string_t& path)
105 | {
106 |     return path.compare(0, DevicePathPrefix.length(), DevicePathPrefix) == 0;
107 | }
108 | 
109 | // Relative here means it could be relative to current directory on the relevant drive
110 | // NOTE: Relative segments ( \..\) are not considered relative
111 | // Returns true if the path specified is relative to the current drive or working directory.
112 | // Returns false if the path is fixed to a specific drive or UNC path.  This method does no
113 | // validation of the path (URIs will be returned as relative as a result).
114 | // Handles paths that use the alternate directory separator.  It is a frequent mistake to
115 | // assume that rooted paths (Path.IsPathRooted) are not relative.  This isn't the case.
116 | 
117 | bool LongFile::IsPathNotFullyQualified(const pal::string_t& path)
118 | {
119 |     if (path.length() < 2)
120 |     {
121 |         return true;  // It isn't fixed, it must be relative.  There is no way to specify a fixed path with one character (or less).
122 |     }
123 | 
124 |     if (IsDirectorySeparator(path[0]))
125 |     {
126 |         return !IsDirectorySeparator(path[1]); // There is no valid way to specify a relative path with two initial slashes
127 |     }
128 | 
129 |     return (path.length() < 3)           //The only way to specify a fixed path that doesn't begin with two slashes is the drive, colon, slash format- "i.e. C:\"
130 |         || (path[1] != VolumeSeparatorChar)
131 |         || !IsDirectorySeparator(path[2]);
132 | }
133 | 
134 | bool LongFile::ContainsDirectorySeparator(const pal::string_t & path)
135 | {
136 |     return path.find(DirectorySeparatorChar) != pal::string_t::npos ||
137 |            path.find(AltDirectorySeparatorChar) != pal::string_t::npos;
138 | }
139 | 
140 | bool LongFile::IsDirectorySeparator(const pal::char_t c)
141 | {
142 |     return c == DirectorySeparatorChar || c == AltDirectorySeparatorChar;
143 | }
144 | 


--------------------------------------------------------------------------------
/libhostfxr/runtime_version.h:
--------------------------------------------------------------------------------
 1 | #define RuntimeAssemblyMajorVersion 0
 2 | #define RuntimeAssemblyMinorVersion 0
 3 | #define RuntimeFileMajorVersion 0
 4 | #define RuntimeFileMinorVersion 0
 5 | #define RuntimeFileBuildVersion 0
 6 | #define RuntimeFileRevisionVersion 0
 7 | #define RuntimeProductMajorVersion 0
 8 | #define RuntimeProductMinorVersion 0
 9 | #define RuntimeProductPatchVersion 0
10 | #define RuntimeProductVersion 0.0.0-dev
11 | 


--------------------------------------------------------------------------------
/libhostfxr/trace.h:
--------------------------------------------------------------------------------
 1 | // Licensed to the .NET Foundation under one or more agreements.
 2 | // The .NET Foundation licenses this file to you under the MIT license.
 3 | 
 4 | #ifndef TRACE_H
 5 | #define TRACE_H
 6 | 
 7 | #include "pal.h"
 8 | 
 9 | namespace trace
10 | {
11 |     void setup();
12 |     bool enable();
13 |     bool is_enabled();
14 |     void verbose(const pal::char_t* format, ...);
15 |     void info(const pal::char_t* format, ...);
16 |     void warning(const pal::char_t* format, ...);
17 |     void error(const pal::char_t* format, ...);
18 |     void println(const pal::char_t* format, ...);
19 |     void println();
20 |     void flush();
21 | 
22 |     typedef void (__cdecl *error_writer_fn)(const pal::char_t* message);
23 | 
24 |     // Sets a callback which is called whenever error is to be written
25 |     // The setting is per-thread (thread local). If no error writer is set for a given thread
26 |     // the error is written to stderr.
27 |     // The callback is set for the current thread which calls this function.
28 |     // The function returns the previously registered writer for the current thread (or null)
29 |     error_writer_fn set_error_writer(error_writer_fn error_writer);
30 | 
31 |     // Returns the currently set callback for error writing
32 |     error_writer_fn get_error_writer();
33 | };
34 | 
35 | #endif // TRACE_H
36 | 


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2024 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     The DotNetPELib library package is free software: you can redistribute it and/or modify
 6 |  *     it under the terms of the GNU Lesser General Public License as published by
 7 |  *     the Free Software Foundation, either version 2.1 of the License, or
 8 |  *     (at your option) any later version.
 9 |  * 
10 |  *     The DotNet PELib library package is distributed in the hope that it will be useful,
11 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  *     GNU General Public License for more details.
14 |  * 
15 |  *     You should have received a copy of the GNU Lesser General Public License
16 |  *     along with DotNetPELib.  If not, see <http://www.gnu.org/licenses/>.
17 |  * 
18 |  *     contact information:
19 |  *         email: TouchStone222@runbox.com <David Lindauer>
20 |  * 
21 |  */
22 | GNU LESSER GENERAL PUBLIC LICENSE
23 | Version 2.1, February 1999 
24 | 


--------------------------------------------------------------------------------
/ms.bat:
--------------------------------------------------------------------------------
1 | msbuild /Property:configuration=Release /Property:platform=x86
2 | 


--------------------------------------------------------------------------------
/netlink/CmdFiles.cpp:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #ifdef HAVE_UNISTD_H
 26 | #    include <unistd.h>
 27 | #    define _access access
 28 | #else
 29 | #    include <io.h>
 30 | #endif
 31 | 
 32 | #include "CmdFiles.h"
 33 | #include "CmdSwitch.h"
 34 | 
 35 | using namespace std;  // borland puts the io stuff in the std namespace...
 36 |                       // microsoft does not seem to.
 37 | 
 38 | const char* CmdFiles::DIR_SEP = "\\";
 39 | const char* CmdFiles::PATH_SEP = ";";
 40 | 
 41 | CmdFiles::~CmdFiles() {}
 42 | bool CmdFiles::Add(char** array, bool recurseDirs)
 43 | {
 44 |     while (*array)
 45 |     {
 46 |         Add(std::string(*array), recurseDirs);
 47 |         array++;
 48 |     }
 49 |     return true;
 50 | }
 51 | bool CmdFiles::RecurseDirs(const std::string& path, const std::string& name, bool recurseDirs)
 52 | {
 53 |     bool rv = false;
 54 | #ifdef TARGET_OS_WINDOWS
 55 |     struct _finddata_t find;
 56 | #endif
 57 |     std::string q = path + "*.*";
 58 |     size_t handle;
 59 |     // borland does not define the char * as const...
 60 | #ifdef TARGET_OS_WINDOWS
 61 |     if ((handle = _findfirst(const_cast<char*>(q.c_str()), &find)) != -1)
 62 |     {
 63 |         do
 64 |         {
 65 |             if (strcmp(find.name, ".") && strcmp(find.name, ".."))
 66 |             {
 67 |                 if (find.attrib & _A_SUBDIR)
 68 |                 {
 69 |                     std::string newName = path + std::string(find.name) + DIR_SEP + name;
 70 |                     rv |= Add(newName, recurseDirs);
 71 |                 }
 72 |             }
 73 |         } while (_findnext(handle, &find) != -1);
 74 |         _findclose(handle);
 75 |     }
 76 | #endif
 77 |     return rv;
 78 | }
 79 | bool CmdFiles::Add(const std::string& name, bool recurseDirs, bool subdirs)
 80 | {
 81 |     bool rv = false;
 82 | #ifdef TARGET_OS_WINDOWS
 83 |     struct _finddata_t find;
 84 | #endif
 85 |     std::string path, lname;
 86 |     size_t n = name.find_last_of(DIR_SEP[0]);
 87 |     size_t n1 = name.find_last_of('/');
 88 |     if (n1 != std::string::npos && n != std::string::npos)
 89 |         n = n1 > n ? n1 : n;
 90 |     else if (n == std::string::npos)
 91 |         n = n1;
 92 |     if (n != std::string::npos)
 93 |     {
 94 |         path = name.substr(0, n + 1);
 95 |         lname = name.substr(n + 1);
 96 |     }
 97 |     else
 98 |     {
 99 |         n = name.find_last_of(':');
100 |         if (n != std::string::npos)
101 |         {
102 |             path = name.substr(0, n + 1);
103 |             lname = name.substr(n + 1);
104 |         }
105 |         else
106 |         {
107 |             lname = name;
108 |         }
109 |     }
110 |     size_t handle;
111 |     // borland does not define the char * as const...
112 | #ifdef TARGET_OS_WINDOWS
113 |     if ((handle = _findfirst(const_cast<char*>(name.c_str()), &find)) != -1)
114 |     {
115 |         do
116 |         {
117 |             if ((!(find.attrib & _A_SUBDIR) || subdirs) && /*!(find.attrib & _A_VOLID) && */
118 |                 !(find.attrib & _A_HIDDEN))
119 |             {
120 |                 if (strcmp(find.name, ".") != 0 && strcmp(find.name, "..") != 0)
121 |                 {
122 |                     std::string file(path + std::string(find.name));
123 |                     names.push_back(file);
124 |                     rv = true;
125 |                 }
126 |             }
127 |         } while (_findnext(handle, &find) != -1);
128 |         _findclose(handle);
129 |     }
130 | #endif
131 |     if (recurseDirs)
132 |     {
133 |         rv |= RecurseDirs(path, lname, recurseDirs);
134 |     }
135 |     if (!rv)
136 |     {
137 |         if (name.find_first_of('*') == std::string::npos && name.find_first_of('?') == std::string::npos)
138 |         {
139 |             names.push_back(name);
140 |             rv = true;
141 |         }
142 |     }
143 |     return rv;
144 | }
145 | bool CmdFiles::AddFromPath(const std::string& name, const std::string& path)
146 | {
147 |     bool rv = false;
148 |     size_t n = name.find_last_of(DIR_SEP[0]);
149 |     size_t n1 = name.find_last_of('/');
150 |     if (n1 != std::string::npos && n != std::string::npos)
151 |         n = n1 > n ? n1 : n;
152 |     if (n != std::string::npos)
153 |     {
154 |         n++;
155 |     }
156 |     else
157 |     {
158 |         n = name.find_first_of(":");
159 |         if (n != std::string::npos)
160 |             n++;
161 |         else
162 |             n = 0;
163 |     }
164 |     std::string internalName = name.substr(n, name.size());
165 |     n = 0;
166 |     bool done = false;
167 |     while (!done)
168 |     {
169 |         size_t m = path.find_first_of(PATH_SEP, n);
170 |         if (m == std::string::npos)
171 |         {
172 |             m = path.size();
173 |             done = true;
174 |         }
175 |         std::string curpath = path.substr(n, m - n);
176 |         n = m + 1;
177 |         if (curpath.size() != 0 && curpath.substr(curpath.size() - 1, curpath.size()) != DIR_SEP)
178 |         {
179 |            curpath += DIR_SEP;
180 |         }
181 |         curpath += internalName;
182 |         if (_access(curpath.c_str(), 0) == 0)
183 |         {
184 |             names.push_back(curpath);
185 |             rv = true;
186 |             break;
187 |         }
188 |     }
189 |     if (!rv)
190 |     {
191 |         names.push_back(name);
192 |         rv = true;
193 |     }
194 |     return rv;
195 | }
196 | bool CmdFiles::Add(CmdSwitchFile& switchFile)
197 | {
198 |     if (switchFile.argv)
199 |         Add(switchFile.argv.get() + 1);
200 |     return true;
201 | }
202 | void CmdFiles::Remove(const std::string& name)
203 | {
204 |     for (int i = 0; i < names.size(); i++)
205 |     {
206 |         if (names[i] == name)
207 |         {
208 |             for (; i < names.size() - 1; i++)
209 |                 names[i] = names[i + 1];
210 |             names.pop_back();
211 |             break;
212 |         }
213 |     }
214 | }


--------------------------------------------------------------------------------
/netlink/CmdFiles.h:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #ifndef CMDFILES_H
26 | #define CMDFILES_H
27 | 
28 | #include <vector>
29 | #include <string>
30 | 
31 | class CmdSwitchFile;
32 | class CmdFiles
33 | {
34 |     typedef std::vector<std::string> FileName;
35 | 
36 |   public:
37 |     CmdFiles() {}
38 |     CmdFiles(char** fileList, bool recurseSubdirs = false) { Add(fileList, recurseSubdirs); }
39 |     CmdFiles(const std::string& name, bool recurseSubdirs = false) { Add(name, recurseSubdirs); }
40 |     ~CmdFiles();
41 | 
42 |     bool Add(const std::string& name, bool recurseSubdirs = false, bool subdirs = false);
43 |     bool AddFromPath(const std::string& name, const std::string& path);
44 |     bool Add(char** fileList, bool recurseSubdirs = false);
45 |     bool Add(CmdFiles& other)
46 |     {
47 |         for (auto a : other.names)
48 |         {
49 |             Add(a);
50 |         }
51 |         return true;
52 |     }
53 |     bool Add(CmdSwitchFile& switchFile);
54 |     void Remove(const std::string& name);
55 |     typedef FileName::iterator iterator;
56 | 
57 |     iterator begin() { return names.begin(); }
58 |     iterator end() { return names.end(); }
59 |     size_t size() const { return names.size(); }
60 |     inline std::string operator[](int index) const 
61 |     { 
62 |         return names[index];
63 |     }
64 |     static const char* DIR_SEP;
65 |     static const char* PATH_SEP;
66 | 
67 |   protected:
68 |     bool RecurseDirs(const std::string& path, const std::string& name, bool recurseDirs);
69 | 
70 |   private:
71 |     FileName names;
72 | };
73 | #endif
74 | 


--------------------------------------------------------------------------------
/netlink/NetLink.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <Text Include="ReadMe.txt" />
19 |   </ItemGroup>
20 |   <ItemGroup>
21 |     <ClInclude Include="targetver.h">
22 |       <Filter>Header Files</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="CmdFiles.h">
25 |       <Filter>Header Files</Filter>
26 |     </ClInclude>
27 |     <ClInclude Include="CmdSwitch.h">
28 |       <Filter>Header Files</Filter>
29 |     </ClInclude>
30 |     <ClInclude Include="Utils.h">
31 |       <Filter>Header Files</Filter>
32 |     </ClInclude>
33 |     <ClInclude Include="NetLinkMain.h">
34 |       <Filter>Header Files</Filter>
35 |     </ClInclude>
36 |     <ClInclude Include="version.h">
37 |       <Filter>Header Files</Filter>
38 |     </ClInclude>
39 |     <ClInclude Include="ToolChain.h">
40 |       <Filter>Header Files</Filter>
41 |     </ClInclude>
42 |   </ItemGroup>
43 |   <ItemGroup>
44 |     <ClCompile Include="CmdFiles.cpp">
45 |       <Filter>Source Files</Filter>
46 |     </ClCompile>
47 |     <ClCompile Include="CmdSwitch.cpp">
48 |       <Filter>Source Files</Filter>
49 |     </ClCompile>
50 |     <ClCompile Include="Utils.cpp">
51 |       <Filter>Source Files</Filter>
52 |     </ClCompile>
53 |     <ClCompile Include="NetLinkMain.cpp">
54 |       <Filter>Source Files</Filter>
55 |     </ClCompile>
56 |     <ClCompile Include="ToolChain.cpp">
57 |       <Filter>Source Files</Filter>
58 |     </ClCompile>
59 |   </ItemGroup>
60 | </Project>


--------------------------------------------------------------------------------
/netlink/NetLink.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
4 |     <LocalDebuggerCommandArguments>r1 r2</LocalDebuggerCommandArguments>
5 |     <LocalDebuggerWorkingDirectory>$(ProjectDir)..\debug</LocalDebuggerWorkingDirectory>
6 |     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
7 |   </PropertyGroup>
8 | </Project>


--------------------------------------------------------------------------------
/netlink/NetLinkMain.h:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #ifndef NetLinkMain_H
 26 | #define NetLinkMain_H
 27 | #include "CmdFiles.h"
 28 | #include "CmdSwitch.h"
 29 | #include "Utils.h"
 30 | #include "ToolChain.h"
 31 | #include <string>
 32 | #include "DotNetPELib.h"
 33 | class NetLinkMain : public DotNetPELib::Callback
 34 | {
 35 | public:
 36 |     NetLinkMain() : 
 37 |         mainContainer(nullptr),
 38 |         mainNameSpace(nullptr), 
 39 |         mainClass(nullptr), 
 40 |         hasEntryPoint(false),
 41 |         peLib(nullptr),
 42 |         mainSym(nullptr),
 43 |         currentMethod(nullptr),
 44 |         netCore(nullptr)
 45 |     { }
 46 | 
 47 |     int Run(int argc, char **argv);
 48 | protected:
 49 | 
 50 |     const std::string &GetAssemblyName(CmdFiles &files);
 51 |     const std::string &GetOutputFile(CmdFiles &files);
 52 |     bool LoadImage(CmdFiles &files);
 53 |     bool Validate();
 54 |     bool CreateExecutable(CmdFiles &files);
 55 |     bool LoadAssembly(const char* assemblyName);
 56 | 
 57 |     DotNetPELib::MethodSignature *LookupSignature(const char * name);
 58 |     DotNetPELib::Field *LookupField(const char *name);
 59 |     DotNetPELib::MethodSignature *LookupManagedSignature(const char *name);
 60 |     DotNetPELib::Field *LookupManagedField(const char *name);
 61 |     void MainLocals(void);
 62 |     void MainInit(void);
 63 |     void dumpInitializerCalls(std::list<DotNetPELib::MethodSignature *>&);
 64 |     void dumpCallToMain(void);
 65 |     void dumpGlobalFuncs();
 66 |     bool AddRTLThunks();
 67 | 
 68 |     // pelib traverse callback
 69 |     virtual bool EnterNamespace(const DotNetPELib::Namespace *nmspc) override;
 70 |     virtual bool EnterClass(const DotNetPELib::Class *method) override;
 71 |     virtual bool EnterMethod(const DotNetPELib::Method *) override;
 72 | private:
 73 | 
 74 |     DotNetPELib::NetCore* netCore;
 75 |     DotNetPELib::PELib *peLib;
 76 |     std::vector<DotNetPELib::Local *> localList;
 77 |     DotNetPELib::MethodSignature *mainSym;
 78 |     DotNetPELib::Method *currentMethod;
 79 |     const DotNetPELib::Namespace *mainNameSpace;
 80 |     const DotNetPELib::Class *mainClass;
 81 |     DotNetPELib::DataContainer *mainContainer;
 82 |     std::list<DotNetPELib::MethodSignature *> initializers, startups;
 83 |     std::list<DotNetPELib::MethodSignature *> destructors, rundowns;
 84 |     std::list<DotNetPELib::MethodSignature *> stringinitializers;
 85 | 
 86 |     std::string namespaceAndClass;
 87 |     bool hasEntryPoint;
 88 | 
 89 |     static CmdSwitchParser SwitchParser;
 90 |     static CmdSwitchBool NoLogo;
 91 |     static CmdSwitchBool ShowVersion;
 92 |     static CmdSwitchBool ShowHelp;
 93 |     static CmdSwitchString StrongName;
 94 |     static CmdSwitchBool LibraryFile;
 95 |     static CmdSwitchBool AssemblyFile;
 96 |     static CmdSwitchBool GUIApp;
 97 |     static CmdSwitchBool Managed;
 98 |     static CmdSwitchOutput AssemblyName;
 99 |     static CmdSwitchString AssemblyVersion;
100 |     static CmdSwitchFile File;
101 |     static CmdSwitchBool CManaged;
102 |     static CmdSwitchBool NoDefaultlibs;
103 |     static CmdSwitchBool WeedPInvokes;
104 |     static CmdSwitchInt NetCoreSwitch;
105 | 
106 |     static const char *usageText;
107 |     static const char* helpText;
108 | };
109 | #endif
110 | 


--------------------------------------------------------------------------------
/netlink/ToolChain.cpp:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #ifndef _CRT_SECURE_NO_WARNINGS
 26 | #define _CRT_SECURE_NO_WARNINGS
 27 | #endif
 28 | #include <cstdio>
 29 | #include <fstream>
 30 | #include <cstdlib>
 31 | #include <cstring>
 32 | #ifdef TARGET_OS_WINDOWS
 33 | #    include <windows.h>
 34 | #endif
 35 | #ifdef HAVE_UNISTD_H
 36 | #    include <unistd.h>
 37 | #    define _access access
 38 | #    define _isatty isatty
 39 | #    include <sys/ioctl.h>
 40 | #else
 41 | #    include <io.h>
 42 | extern "C" char* getcwd(char*, int);
 43 | #    ifdef BORLAND
 44 | #        define _isatty isatty
 45 | #    endif
 46 | #endif
 47 | 
 48 | #include "Utils.h"
 49 | 
 50 | #include "CmdSwitch.h"
 51 | #include "ToolChain.h"
 52 | 
 53 | #include <sstream>
 54 | #include "version.h"
 55 | #include <iostream>
 56 | 
 57 | void ToolChain::ShowBanner()
 58 | {
 59 |     bool have_version = false;
 60 |     // no banner if they specify -!, this is also caught in the cmd switch module
 61 |     // so it is transparent to the proggy
 62 |     const char* modName = Utils::GetModuleName();
 63 |     printf("%s (OrangeC) Version " STRING_VERSION "\n" COPYRIGHT "\n", Utils::ShortName(modName));
 64 | }
 65 | void ToolChain::ShowVersion()
 66 | {
 67 |     printf("\nCompile date: " __DATE__ " time: " __TIME__ "\n");
 68 |     exit(0);
 69 | }
 70 | void ToolChain::Usage(const char* text, int exitVal)
 71 | {
 72 | 
 73 |     int rows = 10000;
 74 | #ifdef TARGET_OS_WINDOWS
 75 |     if (_isatty(fileno(stderr)))
 76 |         rows = ScreenHeight();
 77 | #else
 78 |     if (_isatty(STDERR_FILENO))
 79 |         rows = ScreenHeight();
 80 | #endif
 81 |     const char* modName = Utils::GetModuleName();
 82 |     fprintf(stderr, "\nUsage: %s ", Utils::ShortName(modName));
 83 |     int left = rows - 4;
 84 |     std::string buf;
 85 |     while (GetLine(&text, buf))
 86 |     {
 87 |         std::cerr << buf;
 88 |         if (--left == 0)
 89 |         {
 90 |             std::cerr << "Press <ENTER> to continue...";
 91 |             char temp[512];
 92 |             fgets(temp, sizeof(temp), stdin);
 93 |             left = rows - 1;
 94 |         }
 95 |     }
 96 |     exit(1);
 97 | }
 98 | CmdFiles ToolChain::StandardToolStartup(CmdSwitchParser& SwitchParser, int argc, char** argv, const char* usageText,
 99 |                                         const char* helpText, std::function<bool()> noBanner)
100 | {
101 |     CmdSwitchBool NoLogo(SwitchParser, '!', false, {"nologo"});
102 |     CmdSwitchBool ShowVersion(SwitchParser, 'v', false, {"version"});
103 |     CmdSwitchBool ShowHelp(SwitchParser, '?', false, {"help"});
104 |     CmdSwitchFile File(SwitchParser, '@');
105 |     CmdSwitchFile internalConfig(SwitchParser);
106 | 
107 |     Utils::SetEnvironmentToPathParent("ORANGEC");
108 |     std::string configName = Utils::QualifiedFile(argv[0], ".cfg");
109 |     if (access(configName.c_str(), 0) != 0)
110 |     {
111 |         configName = Utils::QualifiedFile(Utils::GetModuleName(), ".cfg");
112 |     }
113 |     std::fstream configTest(configName, std::ios::in);
114 |     if (!configTest.fail())
115 |     {
116 |         configTest.close();
117 |         if (!internalConfig.Parse(configName.c_str()))
118 |             Utils::Fatal("Corrupt configuration file");
119 |     }
120 |     if (!SwitchParser.Parse(&argc, argv) && !ShowHelp.GetExists())
121 |     {
122 |         if (!noBanner || !noBanner())
123 |             ToolChain::ShowBanner();
124 |         ToolChain::Usage(usageText);
125 |     }
126 |     if (noBanner && noBanner())
127 |         NoLogo.SetValue(true);
128 |     if (!NoLogo.GetValue() || ShowVersion.GetValue())
129 |         ToolChain::ShowBanner();
130 |     if (ShowVersion.GetValue())
131 |         ToolChain::ShowVersion();
132 |     if (ShowHelp.GetExists())
133 |         ToolChain::Usage(helpText);
134 |     auto rv = CmdFiles(argv);
135 |     rv.Add(File);
136 |     return rv;
137 | }
138 | 
139 | int ToolChain::ScreenHeight()
140 | {
141 | #ifdef TARGET_OS_WINDOWS
142 |     CONSOLE_SCREEN_BUFFER_INFO csbi;
143 |     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
144 |     return csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
145 | #else
146 |     struct winsize max;
147 |     ioctl(0, TIOCGWINSZ, &max);
148 |     return max.ws_row;
149 | #endif
150 | }
151 | bool ToolChain::GetLine(const char** text, std::string& buf)
152 | {
153 |     if (!**text)
154 |         return false;
155 |     char const* start = *text;
156 |     auto temp = (char*)strchr(*text, '\n');
157 |     if (!temp)
158 |     {
159 |         *text += strlen(*text);
160 |     }
161 |     else
162 |     {
163 |         *text = temp + 1;
164 |     }
165 |     buf = std::string(start, *text);
166 |     return true;
167 | }
168 | 


--------------------------------------------------------------------------------
/netlink/ToolChain.h:
--------------------------------------------------------------------------------
 1 | /* Software License Agreement
 2 |  * 
 3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
 4 |  * 
 5 |  *     This file is part of the Orange C Compiler package.
 6 |  * 
 7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
 8 |  *     it under the terms of the GNU General Public License as published by
 9 |  *     the Free Software Foundation, either version 3 of the License, or
10 |  *     (at your option) any later version.
11 |  * 
12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 |  *     GNU General Public License for more details.
16 |  * 
17 |  *     You should have received a copy of the GNU General Public License
18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
19 |  * 
20 |  *     contact information:
21 |  *         email: TouchStone222@runbox.com <David Lindauer>
22 |  * 
23 |  */
24 | 
25 | #ifndef TOOLCHAIN_H
26 | #define TOOLCHAIN_H
27 | #ifndef _CRT_SECURE_NO_WARNINGS
28 | #    define _CRT_SECURE_NO_WARNINGS
29 | #endif
30 | #include <string>
31 | #include <cstdlib>
32 | #include <cstring>
33 | #include <vector>
34 | #include "Utils.h"
35 | #include "CmdFiles.h"
36 | #include <functional>
37 | 
38 | #ifdef TARGET_OS_WINDOWS
39 | #    define mysystem(x) winsystem(x)
40 | extern "C" int winsystem(const char*);
41 | #else
42 | #    define mysystem(x) system(x)
43 | #endif
44 | 
45 | class CmdSwitchParser;
46 | 
47 | class ToolChain
48 | {
49 |   public:
50 |     static CmdFiles StandardToolStartup(CmdSwitchParser& SwitchParser, int argc, char** argv, const char* usageText,
51 |                                                    const char* helpText, std::function<bool()> noBanner = nullptr);
52 |     static void ShowBanner();
53 |     static void ShowVersion();
54 |     static void Usage(const char* text, int exitVal = 1);
55 |     template <typename... Args>
56 |     static int ToolInvoke(const std::string& exeName, const char* with, const char* fmt, const Args... arg)
57 |     {
58 |         int size = snprintf(NULL, 0, fmt, arg...) + 260;
59 |         char *buf = (char *)calloc(sizeof(char), size);
60 |         buf[0] = '"';
61 |         strcpy(buf + 1, Utils::GetModuleName());
62 |         char* p = (char*)strrchr(buf, '/');
63 |         char* p1 = (char*)strrchr(buf, '\\');
64 |         if (p1 > p)
65 |             p = p1;
66 |         else if (!p)
67 |             p = p1;
68 |         if (p)
69 |         {
70 |             p++;
71 |         }
72 |         else
73 |         {
74 |             p = buf + 1;
75 |         }
76 |         *p = 0;
77 |         strcat(p, exeName.c_str());
78 |         strcat(p, "\" ");
79 |         sprintf(buf + strlen(buf), fmt, arg...);
80 |         if (with)
81 |         {
82 |             printf("%s\n", buf);
83 |             if (with[0])
84 |                 printf("   with %s", with);
85 |         }
86 |         auto rv = mysystem(buf);
87 |         free(buf);
88 |         return rv;
89 |     }
90 | 
91 |   private:
92 |     static int ScreenHeight();
93 |     static bool GetLine(const char** text, std::string& buf);
94 | };
95 | #endif


--------------------------------------------------------------------------------
/netlink/Utils.h:
--------------------------------------------------------------------------------
  1 | /* Software License Agreement
  2 |  * 
  3 |  *     Copyright(C) 1994-2023 David Lindauer, (LADSoft)
  4 |  * 
  5 |  *     This file is part of the Orange C Compiler package.
  6 |  * 
  7 |  *     The Orange C Compiler package is free software: you can redistribute it and/or modify
  8 |  *     it under the terms of the GNU General Public License as published by
  9 |  *     the Free Software Foundation, either version 3 of the License, or
 10 |  *     (at your option) any later version.
 11 |  * 
 12 |  *     The Orange C Compiler package is distributed in the hope that it will be useful,
 13 |  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 |  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 |  *     GNU General Public License for more details.
 16 |  * 
 17 |  *     You should have received a copy of the GNU General Public License
 18 |  *     along with Orange C.  If not, see <http://www.gnu.org/licenses/>.
 19 |  * 
 20 |  *     contact information:
 21 |  *         email: TouchStone222@runbox.com <David Lindauer>
 22 |  * 
 23 |  */
 24 | 
 25 | #ifndef UTIL_H
 26 | #define UTIL_H
 27 | #ifndef _CRT_SECURE_NO_WARNINGS
 28 | #    define _CRT_SECURE_NO_WARNINGS
 29 | #endif
 30 | #include <string>
 31 | #include <cstdlib>
 32 | #include <cstring>
 33 | #include <vector>
 34 | 
 35 | #ifdef TARGET_OS_WINDOWS
 36 | #    include "io.h"
 37 | #endif
 38 | 
 39 | class Utils
 40 | {
 41 |   public:
 42 |     [[noreturn]] static void Fatal(const char* format)
 43 |     {
 44 |         fprintf(stderr, "Fatal error: ");
 45 |         fputs(format, stderr);
 46 |         if (cleanup)
 47 |             cleanup();
 48 |         exit(1);
 49 |     }
 50 |     template <typename... Args>  // templates are MUCH more portable than varargs
 51 |     [[noreturn]] static void Fatal(const char* format, Args... arg)
 52 |     {
 53 |         fprintf(stderr, "Fatal error: ");
 54 |         fprintf(stderr, format, arg...);
 55 |         fputc('\n', stderr);
 56 |         if (cleanup)
 57 |             cleanup();
 58 |         exit(1);
 59 |     }
 60 |     [[noreturn]] static void Fatal(const std::string& format) { Fatal(format.c_str()); }
 61 |     template <typename... Args>
 62 |     [[noreturn]] static void Fatal(const std::string& format, Args... arg)
 63 |     {
 64 |         Fatal(format.c_str(), arg...);
 65 |     }
 66 |     static bool HasLocalExe(const std::string& exeName);
 67 |     static void SetCleanup(void(Cleanup)()) { cleanup = Cleanup; }
 68 |     static char* GetModuleName();
 69 |     static void SetEnvironmentToPathParent(const char* name);
 70 |     static std::string FullPath(const std::string& path, const std::string& name);
 71 |     static std::string AbsolutePath(const std::string& name);
 72 |     static std::string QualifiedFile(const char* path, const char* ext);
 73 |     static char* FullQualify(char* string);
 74 |     static std::string SearchForFile(const std::string& path, const std::string& name);
 75 |     static std::string NumberToString(int num);
 76 |     static std::string NumberToStringHex(int num);
 77 |     static int StringToNumber(std::string str);
 78 |     static int StringToNumberHex(std::string str);
 79 |     static char* ShortName(const char* v);
 80 |     static bool iequal(const std::string& left, const std::string& right, int sz = -1);
 81 |     static FILE* TempName(std::string& name);
 82 |     static void AddExt(char* buffer, const char* ext);
 83 |     static void StripExt(char* buffer);
 84 |     static bool HasExt(const char* buffer, const char* ext);
 85 |     static bool FileExists(const char* buffer);
 86 |     static std::string FindOnPath(const std::string& name, const std::string& path);
 87 |     static std::vector<std::string> split(const std::string& strToSplit, char delimeter = ';');
 88 |     static void ReplaceAll(std::string& str, const std::string& from, const std::string& to);
 89 |     static std::string ConvertWStringToString(std::wstring str)
 90 |     {
 91 |         char intStr[256];
 92 |         size_t sz = wcstombs(nullptr, str.c_str(), 256);
 93 |         sz = wcstombs(intStr, str.c_str(), sz);
 94 |         return std::string(intStr, sz);
 95 |     }
 96 |     static bool NamedPipe(int* fds, const std::string& name);
 97 |     static bool PipeWrite(int fileno, const std::string& data);
 98 |     static std::string PipeRead(int fileno);
 99 | 
100 |     static unsigned PartialCRC32(unsigned crc, const unsigned char* data, size_t len);
101 |     static unsigned CRC32(const unsigned char* data, size_t len) { return PartialCRC32(0, data, len); };
102 | 
103 |     static unsigned Random(unsigned);
104 | 
105 |     static char* StrCpy(char* data, size_t len, const char* source)
106 |     {
107 |         strncpy(data, source, len);
108 |         data[len - 1] = '\0';
109 |         return data;
110 |     }
111 |     template <size_t len>
112 |     static char* StrCpy(char (&data)[len], const char* source)
113 |     {
114 |         return StrCpy(data, len, source);
115 |     }
116 |     static char* StrCat(char* data, size_t len, const char* source)
117 |     {
118 |         int num = (int)len - (int)strlen(data) - 1;
119 |         if (num > 0)
120 |             strncat(data, source, num);
121 |         return data;
122 |     }
123 |     template <size_t len>
124 |     static char* StrCat(char (&data)[len], const char* source)
125 |     {
126 |         return StrCat(data, len, source);
127 |     }
128 |     template <size_t len>
129 |     static unsigned CRC32(const unsigned char (&data)[len])
130 |     {
131 |         return CRC32(data, len);
132 |     }
133 |     template <size_t len>
134 |     static unsigned PartialCRC32(unsigned crc, const unsigned char* data)
135 |     {
136 |         return PartialCRC32(crc, data, len);
137 |     }
138 |     static unsigned crctab[256];
139 | 
140 |   private:
141 |     static void (*cleanup)();
142 | };
143 | #endif


--------------------------------------------------------------------------------
/netlink/dummy.cpp:
--------------------------------------------------------------------------------
1 | // placeholder to make build happy


--------------------------------------------------------------------------------
/netlink/makefile:
--------------------------------------------------------------------------------
 1 | #	Software License Agreement (BSD License)
 2 | #	
 3 | #	Copyright (c) 1997-2009, David Lindauer, (LADSoft).
 4 | #	All rights reserved.
 5 | #	
 6 | #	Redistribution and use of this software in source and binary forms, 
 7 | #	with or without modification, are permitted provided that the following 
 8 | #	conditions are met:
 9 | 
10 | #	* Redistributions of source code must retain the above
11 | #	  copyright notice, this list of conditions and the
12 | #	  following disclaimer.
13 | 
14 | #	* Redistributions in binary form must reproduce the above
15 | #	  copyright notice, this list of conditions and the
16 | #	  following disclaimer in the documentation and/or other
17 | #	  materials provided with the distribution.
18 | 
19 | #	* Neither the name of LADSoft nor the names of its
20 | #	  contributors may be used to endorse or promote products
21 | #	  derived from this software without specific prior
22 | #	  written permission of LADSoft.
23 | 
24 | #	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
25 | #	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
26 | #	THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
27 | #	PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
28 | #	OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
29 | #	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
30 | #	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
31 | #	OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
32 | #	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
33 | #	OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
34 | #	ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 | 
36 | #	contact information:
37 | #		email: TouchStone222@runbox.com <David Lindauer>
38 | NAME=netlink
39 | MAIN_FILE=NetLinkMain.cpp
40 | INCLUDES=..\ 
41 | CPP_DEPENDENCIES=\
42 |     CmdFiles.cpp\
43 |     CmdSwitch.cpp\
44 |     Utils.cpp
45 | LIB_DEPENDENCIES=netlib
46 | 
47 | compiler:
48 | 	@$(MAKE) /T
49 | 	copy netlink.exe ..\..
50 | 
51 | DISTRIBUTE: copyexe
52 | 


--------------------------------------------------------------------------------
/netlink/netlink.exe.manifest:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
 2 | <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
 3 |   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
 4 |     <security>
 5 |       <requestedPrivileges>
 6 |         <requestedExecutionLevel level='asInvoker' uiAccess = 'false' />
 7 |       </requestedPrivileges>
 8 |     </security>
 9 |   </trustInfo>
10 | </assembly>
11 | 


--------------------------------------------------------------------------------
/netlink/targetver.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Including SDKDDKVer.h defines the highest available Windows platform.
4 | 
5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
7 | 
8 | #include <SDKDDKVer.h>
9 | 


--------------------------------------------------------------------------------
/netlink/version.h:
--------------------------------------------------------------------------------
1 | #define STRING_VERSION "6.73.1"
2 | #define PRODUCT_VERSION 6,0,73,1
3 | #define CLIB_VERSION 6,0,73,1
4 | #define PRODUCT_STRING_VERSION STRING_VERSION
5 | #define PRODUCT_NAME "Orange C Compiler Package"
6 | #define CLIB_STRING_VERSION STRING_VERSION
7 | #define COPYRIGHT "Copyright (C) LADSoft 2006-2024"
8 | #define LIBRARY_COPYRIGHT "Copyright (C) LADSoft 1994-2024"
9 | 


--------------------------------------------------------------------------------
/sha1.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *  sha1.h
 3 |  *
 4 |  *  Copyright (C) 1998, 2009
 5 |  *  Paul E. Jones <paulej@packetizer.com>
 6 |  *  All Rights Reserved
 7 |  *
 8 |  *****************************************************************************
 9 |  *  $Id: sha1.h 12 2009-06-22 19:34:25Z paulej $
10 |  *****************************************************************************
11 |  *
12 |  *  Description:
13 |  *      This class implements the Secure Hashing Standard as defined
14 |  *      in FIPS PUB 180-1 published April 17, 1995.
15 |  *
16 |  *      Many of the variable names in the SHA1Context, especially the
17 |  *      single character names, were used because those were the names
18 |  *      used in the publication.
19 |  *
20 |  *      Please read the file sha1.c for more information.
21 |  *
22 |  */
23 | 
24 | #ifndef _SHA1_H_
25 | #define _SHA1_H_
26 | 
27 | namespace DotNetPELib {
28 | /* 
29 |  *  This structure will hold context information for the hashing
30 |  *  operation
31 |  */
32 | typedef struct SHA1Context
33 | {
34 |     unsigned Message_Digest[5]; /* Message Digest (output)          */
35 | 
36 |     unsigned Length_Low;        /* Message length in bits           */
37 |     unsigned Length_High;       /* Message length in bits           */
38 | 
39 |     unsigned char Message_Block[64]; /* 512-bit message blocks      */
40 |     int Message_Block_Index;    /* Index into message block array   */
41 | 
42 |     int Computed;               /* Is the digest computed?          */
43 |     int Corrupted;              /* Is the message digest corruped?  */
44 | } SHA1Context;
45 | 
46 | /*
47 |  *  Function Prototypes
48 |  */
49 | void SHA1Reset(SHA1Context *);
50 | int SHA1Result(SHA1Context *);
51 | void SHA1Input( SHA1Context *,
52 |                 const unsigned char *,
53 |                 unsigned);
54 | 
55 | } // NameSpace
56 | #endif
57 | 


--------------------------------------------------------------------------------
/targetver.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | // Including SDKDDKVer.h defines the highest available Windows platform.
4 | 
5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
7 | 
8 | #include <SDKDDKVer.h>
9 | 


--------------------------------------------------------------------------------
/test/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
5 |     </startup>
6 | </configuration>
7 | 


--------------------------------------------------------------------------------
/test/DumpMSCorLib.cpp:
--------------------------------------------------------------------------------
  1 | // this is an example of how to use traversal to dump the public members of a .net assembly
  2 | // instead of dumping them you could load them into a compiler's symbol table, for example..
  3 | #include "DotNetPELib.h"
  4 | 
  5 | #include <fstream>
  6 | #include <deque>
  7 | #include <string>
  8 | using namespace DotNetPELib;
  9 | 
 10 | class Importer :public Callback
 11 | {
 12 | public:
 13 |     Importer() { }
 14 |     virtual ~Importer() { }
 15 | 
 16 |     virtual bool EnterAssembly(const AssemblyDef *) override;
 17 |     virtual bool ExitAssembly(const AssemblyDef *) override;
 18 |     virtual bool EnterNamespace(const Namespace *) override;
 19 |     virtual bool ExitNamespace(const Namespace *) override;
 20 |     virtual bool EnterClass(const Class *) override;
 21 |     virtual bool ExitClass(const Class *) override;
 22 |     virtual bool EnterEnum(const Enum *cls) override;
 23 |     virtual bool ExitEnum(const Enum *cls) override;
 24 |     virtual bool EnterMethod(const Method *) override;
 25 |     virtual bool EnterField(const Field *) override;
 26 |     virtual bool EnterProperty(const Property *) override;
 27 | 
 28 |     void diag(std::string header, std::string name)
 29 |     {
 30 |         
 31 |         for (int i = 0; i < names_.size(); i++)
 32 |             std::cout << "\t";
 33 |         if (header.size())
 34 |             std::cout << header << " ";
 35 |         for (int i = 0; i < names_.size(); i++)
 36 |             std::cout << names_[i] << ".";
 37 |         std::cout << name << std::endl;
 38 |     }
 39 | private:
 40 |     std::deque<std::string > names_;
 41 | };
 42 | 
 43 | void main()
 44 | {
 45 |     PELib lib("test", PELib::ilonly);
 46 | 
 47 |     if (!lib.LoadAssembly("mscorlib"))
 48 |     {
 49 |         Importer importer;
 50 |         lib.Traverse(importer);
 51 |     }
 52 | }
 53 | 
 54 | 
 55 | bool Importer::EnterAssembly(const AssemblyDef *assembly)
 56 | {
 57 |     diag("Assembly", assembly->Name());
 58 |     names_.push_back(assembly->Name());
 59 |     return true;
 60 | }
 61 | bool Importer::ExitAssembly(const AssemblyDef *assembly) 
 62 | {
 63 |     names_.pop_back();
 64 |     diag("Exit Assembly", assembly->Name());
 65 |     return true;
 66 | }
 67 | bool Importer::EnterNamespace(const Namespace *nameSpace)
 68 | {
 69 |     diag("Namespace", nameSpace->Name());
 70 |     names_.push_back(nameSpace->Name());
 71 |     return true;
 72 | }
 73 | bool Importer::ExitNamespace(const Namespace *nameSpace)
 74 | {
 75 |     names_.pop_back();
 76 |     diag("Exit Namespace", nameSpace->Name());
 77 |     return true;
 78 | }
 79 | bool Importer::EnterClass(const Class *cls)
 80 | {
 81 |     diag("Class", cls->Name());
 82 |     names_.push_back(cls->Name());
 83 |     return true;
 84 | }
 85 | bool Importer::ExitClass(const Class *cls)
 86 | {
 87 |     names_.pop_back();
 88 |     diag("Exit Class", cls->Name());
 89 |     return true;
 90 | }
 91 | bool Importer::EnterEnum(const Enum *cls)
 92 | {
 93 |     diag("Enum", cls->Name());
 94 |     names_.push_back(cls->Name());
 95 |     return true;
 96 | }
 97 | bool Importer::ExitEnum(const Enum *cls)
 98 | {
 99 |     names_.pop_back();
100 |     diag("Exit Enum", cls->Name());
101 |     return true;
102 | }
103 | bool Importer::EnterMethod(const Method *method)
104 | {
105 |     diag("Method", method->Signature()->Name());
106 |     return true;
107 | }
108 | bool Importer::EnterField(const Field *field)
109 | {
110 |     diag("Field", field->Name());
111 |     return true;
112 | }
113 | bool Importer::EnterProperty(const Property *property)
114 | {
115 |     diag("Property", property->Name());
116 |     return true;
117 | }


--------------------------------------------------------------------------------
/test/DumpMSCorLib.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <Text Include="ReadMe.txt" />
19 |   </ItemGroup>
20 |   <ItemGroup>
21 |     <ClInclude Include="targetver.h">
22 |       <Filter>Header Files</Filter>
23 |     </ClInclude>
24 |   </ItemGroup>
25 |   <ItemGroup>
26 |     <ClCompile Include="DumpMSCorLib.cpp">
27 |       <Filter>Source Files</Filter>
28 |     </ClCompile>
29 |   </ItemGroup>
30 | </Project>


--------------------------------------------------------------------------------
/test/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("testcsc")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Hewlett-Packard")]
12 | [assembly: AssemblyProduct("testcsc")]
13 | [assembly: AssemblyCopyright("Copyright © Hewlett-Packard 2017")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("5be35f88-e1cb-4aaf-acc9-5227b5143b17")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/test/test.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="test.cpp">
19 |       <Filter>Source Files</Filter>
20 |     </ClCompile>
21 |   </ItemGroup>
22 | </Project>


--------------------------------------------------------------------------------
/test/testcsc.cs:
--------------------------------------------------------------------------------
 1 | namespace a.b.c
 2 | {
 3 | 	public class r
 4 | 	{
 5 | 		public class s
 6 | 		{
 7 | 			private static int _myprop;
 8 | 			public static int zz = 5;
 9 | 			public static int myprop {
10 | 				get {
11 | 					return _myprop + 11;
12 | 				}
13 | 				set {
14 | 					_myprop = value + 22;
15 | 				}
16 | 			}
17 | 		}
18 | 	}
19 | 	
20 | };


--------------------------------------------------------------------------------
/test/testcsc.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 4 |   <PropertyGroup>
 5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 7 |     <ProjectGuid>{5BE35F88-E1CB-4AAF-ACC9-5227B5143B17}</ProjectGuid>
 8 |     <OutputType>Library</OutputType>
 9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
10 |     <RootNamespace>testcsc</RootNamespace>
11 |     <AssemblyName>testcsc</AssemblyName>
12 |     <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
13 |     <FileAlignment>512</FileAlignment>
14 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
15 |     <TargetFrameworkProfile />
16 |   </PropertyGroup>
17 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
18 |     <PlatformTarget>AnyCPU</PlatformTarget>
19 |     <DebugSymbols>true</DebugSymbols>
20 |     <DebugType>full</DebugType>
21 |     <Optimize>false</Optimize>
22 |     <OutputPath>bin\Debug\</OutputPath>
23 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
24 |     <ErrorReport>prompt</ErrorReport>
25 |     <WarningLevel>4</WarningLevel>
26 |   </PropertyGroup>
27 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
28 |     <PlatformTarget>AnyCPU</PlatformTarget>
29 |     <DebugType>pdbonly</DebugType>
30 |     <Optimize>true</Optimize>
31 |     <OutputPath>bin\Release\</OutputPath>
32 |     <DefineConstants>TRACE</DefineConstants>
33 |     <ErrorReport>prompt</ErrorReport>
34 |     <WarningLevel>4</WarningLevel>
35 |   </PropertyGroup>
36 |   <PropertyGroup>
37 |     <StartupObject />
38 |   </PropertyGroup>
39 |   <ItemGroup>
40 |     <Reference Include="System" />
41 |     <Reference Include="System.Core" />
42 |     <Reference Include="System.Xml.Linq" />
43 |     <Reference Include="System.Data.DataSetExtensions" />
44 |     <Reference Include="Microsoft.CSharp" />
45 |     <Reference Include="System.Data" />
46 |     <Reference Include="System.Net.Http" />
47 |     <Reference Include="System.Xml" />
48 |   </ItemGroup>
49 |   <ItemGroup>
50 |     <Compile Include="Properties\AssemblyInfo.cs" />
51 |     <Compile Include="testcsc.cs" />
52 |   </ItemGroup>
53 |   <ItemGroup>
54 |     <None Include="App.config" />
55 |   </ItemGroup>
56 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
57 |   <PropertyGroup>
58 |     <PostBuildEvent>mkdir $(ProjectDir)$(ConfigurationName)
59 | copy $(TargetPath) $(ProjectDir)$(ConfigurationName)</PostBuildEvent>
60 |   </PropertyGroup>
61 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
62 |        Other similar extension points exist, see Microsoft.Common.targets.
63 |   <Target Name="BeforeBuild">
64 |   </Target>
65 |   <Target Name="AfterBuild">
66 |   </Target>
67 |   -->
68 | </Project>


--------------------------------------------------------------------------------
/testcore/test.cpp:
--------------------------------------------------------------------------------
  1 | #include "DotNetPELib.h"
  2 | 
  3 | using namespace DotNetPELib;
  4 | 
  5 | void build_dll(std::string assembly, PELib::CorFlags mode = PELib::cfnone)
  6 | {
  7 |     NetCore core((PELib::CorFlags)(PELib::ilonly | mode));
  8 |     PELib* libEntry = core.init(assembly);
  9 | 
 10 |     DataContainer* working = libEntry->WorkingAssembly();
 11 | 
 12 |     Namespace* nmspc = libEntry->AllocateNamespace("nmspc");
 13 |     working->Add(nmspc);
 14 |     Class* cls = libEntry->AllocateClass("cls", Qualifiers::Public | Qualifiers::Ansi | Qualifiers::Sealed, -1, -1);
 15 |         nmspc->Add(cls);
 16 | 
 17 |     MethodSignature* signatures = libEntry->AllocateMethodSignature("Start", MethodSignature::Managed, cls);
 18 |     signatures->ReturnType(libEntry->AllocateType(Type::Void, 0));
 19 |     Param* parames1 = libEntry->AllocateParam("strn", libEntry->AllocateType(Type::string, 0));
 20 |     signatures->AddParam(parames1);
 21 | 
 22 |     // add a reference to the assembly
 23 |     core.LoadAssembly("System.Runtime");
 24 |     core.LoadAssembly("System.Console");
 25 | 
 26 |     // create the function refernce to WriteLine
 27 |     // there is an argument matcher in the library, set up a vector of types describing
 28 |     // the arguments and it will try to find a matching overload.
 29 |     Type tp(Type::string, 0);
 30 |     std::vector<Type*> typeList;
 31 |     typeList.push_back(&tp);
 32 |     Method* result = nullptr;
 33 |     MethodSignature* signaturep;
 34 |     if (libEntry->Find("System.Console.WriteLine", &result, typeList) == PELib::s_method)
 35 |     {
 36 |         signaturep = result->Signature();
 37 |     }
 38 |     else
 39 |     {
 40 |         std::cout << "error" << std::endl;
 41 |         exit(1);
 42 |     }
 43 | 
 44 |     Method* start = libEntry->AllocateMethod(signatures, Qualifiers::Public |
 45 |         Qualifiers::Static |
 46 |         Qualifiers::HideBySig |
 47 |         Qualifiers::CIL |
 48 |         Qualifiers::Managed);
 49 |     start->AddInstruction(libEntry->AllocateInstruction(Instruction::i_ldarg,
 50 |         libEntry->AllocateOperand(parames1)));
 51 |     start->AddInstruction(libEntry->AllocateInstruction(Instruction::i_call,
 52 |         libEntry->AllocateOperand(libEntry->AllocateMethodName(signaturep))));
 53 | 
 54 |     start->AddInstruction(libEntry->AllocateInstruction(Instruction::i_ldstr,
 55 |         libEntry->AllocateOperand("this is a string in Start()", true)));
 56 |     start->AddInstruction(libEntry->AllocateInstruction(Instruction::i_call,
 57 |         libEntry->AllocateOperand(libEntry->AllocateMethodName(signaturep))));
 58 | 
 59 |     start->AddInstruction(libEntry->AllocateInstruction(Instruction::i_ret, nullptr));
 60 | 
 61 |     try
 62 |     {
 63 |         start->Optimize(*libEntry);
 64 |     }
 65 |     catch (PELibError exc)
 66 |     {
 67 |         std::cout << "Optimizer error: " << exc.what() << std::endl;
 68 |     }
 69 |     cls->Add(start);
 70 | 
 71 |     core.DumpOutputFile(assembly + ".il", PELib::ilasm);
 72 |     core.DumpOutputFile(assembly + ".dll", PELib::pedll);
 73 | 
 74 | }
 75 | void build_exe(std::string assembly, std::string lib, PELib::CorFlags mode = PELib::cfnone)
 76 | {
 77 |     NetCore core((PELib::CorFlags)(PELib::ilonly | mode));
 78 |     PELib *libEntry = core.init(assembly);
 79 | 
 80 |     DataContainer* working = libEntry->WorkingAssembly();
 81 |     Class* cls = libEntry->AllocateClass("Program", Qualifiers::Private | Qualifiers::Ansi | Qualifiers::Auto | Qualifiers::BeforeFieldInit, -1, -1);
 82 |     working->Add(cls);
 83 | 
 84 |     // add a reference to the assembly
 85 |     core.LoadAssembly("System.Runtime");
 86 |     core.LoadAssembly(lib);
 87 | 
 88 |     MethodSignature* signaturem = libEntry->AllocateMethodSignature("<Main>$", MethodSignature::Managed, working);
 89 |     signaturem->ReturnType(libEntry->AllocateType(Type::Void, 0));
 90 |     Method* main = libEntry->AllocateMethod(signaturem, Qualifiers::Private |
 91 |         Qualifiers::Static |
 92 |         Qualifiers::HideBySig |
 93 |         Qualifiers::CIL |
 94 |         Qualifiers::Managed, true);
 95 |     cls->Add(main);
 96 | 
 97 |     Type tp(Type::string, 0);
 98 |     std::vector<Type*> typeList;
 99 |     typeList.push_back(&tp);
100 |     Method* result = nullptr;
101 |     MethodSignature* signaturep;
102 |     if (libEntry->Find("nmspc.cls.Start", &result, typeList) == PELib::s_method)
103 |     {
104 |         signaturep = result->Signature();
105 |     }
106 |     else
107 |     {
108 |         std::cout << "error" << std::endl;
109 |         exit(1);
110 |     }
111 |     // note the reference to the generic form of ldc.i4 ... it will be optimized
112 |     // into an ldc.i4.s by the library
113 |     main->AddInstruction(libEntry->AllocateInstruction(Instruction::i_ldstr,
114 |         libEntry->AllocateOperand("this is a string in <Main>$()", true)));
115 |     main->AddInstruction(libEntry->AllocateInstruction(Instruction::i_call,
116 |         libEntry->AllocateOperand(libEntry->AllocateMethodName(signaturep))));
117 |     main->AddInstruction(libEntry->AllocateInstruction(Instruction::i_ret, nullptr));
118 |     try
119 |     {
120 |         main->Optimize(*libEntry);
121 |     }
122 |     catch (PELibError exc)
123 |     {
124 |         std::cout << "Optimizer error: " << exc.what() << std::endl;
125 |     }
126 |     core.DumpOutputFile(assembly + ".il", PELib::ilasm);
127 |     core.DumpOutputFile(assembly + ".exe", PELib::peexe);
128 | 
129 | }
130 | int main()
131 | {
132 |     for (int i = 5; i < 10; i++)
133 |     {
134 |         NetCore core(PELib::cfnone, false, i);
135 |         std::cout << i << ": " << core.SupportsRuntime(i) << std::endl;
136 |     }
137 |     build_dll("libcore32", PELib::bits32);
138 |     build_exe("testcore32", "libcore32", PELib::bits32);
139 |     build_dll("libcore64");
140 |     build_exe("testcore64", "libcore64");
141 | }


--------------------------------------------------------------------------------
/testcore/testcore.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="test.cpp">
19 |       <Filter>Source Files</Filter>
20 |     </ClCompile>
21 |   </ItemGroup>
22 | </Project>


--------------------------------------------------------------------------------
/util/dump.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LADSoft/DotNetPELib/8282f8a7ef7bc53ad5f443a9c382ce91d89c3aee/util/dump.c


--------------------------------------------------------------------------------
/vcvars32.bat:
--------------------------------------------------------------------------------
1 | 
2 | 
3 | @call "%~dp0vcvarsall.bat" x86 %*
4 | 


--------------------------------------------------------------------------------