public MSG_S2C_HEADER(DWORD uid, WORD protocol)
{
dwPCID = uid;
byCtrl = 0x03;
byCmd = 0xFF;
wProtocol = protocol;
}
void SendCmd(WORD wDevID, BYTE wCmdOrAck, int nParam)
{
CMD_PKT pkt = new CMD_PKT();
BYTE[] pktBuffer = new BYTE[12];
pkt.Head1 = (BYTE)COMMAND_START_CODE1;
pkt.Head2 = (BYTE)COMMAND_START_CODE2;
pkt.wDevId0 = (byte)(wDevID & 0xFF);
pkt.wDevId1 = (byte)(wDevID >> 8);
pkt.nParam0 = (byte)(nParam & 0xFF);
pkt.nParam1 = (byte)((nParam & 0xFF00) >> 8);
pkt.nParam2 = (byte)((nParam & 0xFF0000) >> 16);
pkt.nParam3 = (byte)((nParam & 0xFF000000) >> 24);
pkt.wCmd0 = wCmdOrAck;
pkt.wCmd1 = 0x00;
WORD chksum = CalcChkSumOfCmd(ref pkt);
pkt.wChkSum0 = (byte)(chksum % 256);
pkt.wChkSum1 = (byte)(chksum >> 8);
pktBuffer = PktToByteArray(ref pkt);
serial.Write(pktBuffer, 0, PKT_SIZE);
}
public static extern Boolean SetupDiGetDeviceInterfaceDetail(
HDEVINFO DeviceInfoSet,
ref SP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
IntPtr DeviceInterfaceDetailData, //ref SP_DEVICE_INTERFACE_DETAIL_DATA
DWORD DeviceInterfaceDetailDataSize,
ref WORD RequiredSize,
IntPtr DeviceInfoData //ref SP_DEVINFO_DATA
);
public WORD readWord(ushort address)
{
var word = new WORD();
word.low = data[address];
word.high = data[address + 1];
return(word);
}
static public WORD BCDToWORD(byte[] bcd)
{
WORD result = 0;
result += (WORD)(1000 * (bcd[0] >> 4));
result += (WORD)(100 * (bcd[0] & 0xf));
result += (WORD)(10 * (bcd[1] >> 4));
result += (WORD)(bcd[1] & 0xf);
return(result);
}
WORD CalcChkSumOfDataPkt(ref BYTE[] DataPkt, int nSize)
{
int i;
WORD wChkSum = 0;
for (i = 0; i < nSize; i++)
{
wChkSum += DataPkt[i];
}
return(wChkSum);
}
WORD CalcChkSumOfCmd(ref CMD_PKT pPkt)
{
WORD wChkSum = 0;
BYTE[] Buf = PktToByteArray(ref pPkt);
int i;
for (i = 0; i < (PKT_SIZE - CHK_SUM_SIZE); i++)
{
wChkSum += Buf[i];
}
return(wChkSum);
}
public BITMAPINFOHEADER(int width, int height)
{
biSize = (uint)Marshal.SizeOf <BITMAPINFOHEADER>();
biWidth = width;
biHeight = -height;
biPlanes = 1;
biBitCount = 32;
biCompression = BI_RGB;
biSizeImage = 0;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
biClrUsed = 0;
biClrImportant = 0;
}
private void Form1_Load(object sender, EventArgs e)
{
string[] ports = SerialPort.GetPortNames();
comboBox_COM.Items.AddRange(ports);
textBox_IMEI.Enabled = false;
//textBox_SIMNUM.Enabled = false;
//textBox_STFWPASS.Text = "LteWater_0122.bin";
StreamReader pth = new StreamReader("C:\\LTEW\\STFW\\STFW.txt", Encoding.Default);
string WORD;
while ((WORD = pth.ReadLine()) != null)
{
string[] sbuf = WORD.Split(',');
textBox_STFWPASS.Text = sbuf[0];
textBox_STFWVER.Text = sbuf[1];
}
pth.Close();
StreamReader dis = new StreamReader("C:\\LTEW\\tools\\distance.txt", Encoding.Default);
string dist;
dist = dis.ReadLine();
textBox_TESTDIS.Text = dist;
dis.Close();
StreamReader volt = new StreamReader("C:\\LTEW\\tools\\voltage.txt", Encoding.Default);
string voltage;
voltage = volt.ReadLine();
textBox_voltage.Text = voltage;
volt.Close();
StreamReader pro = new StreamReader("C:\\LTEW\\tools\\Product.csv", Encoding.Default);
string PRONUM;
int i = 0;
while ((PRONUM = pro.ReadLine()) != null)
{
i++;
}
i = i - 1;
textBox_COUNT.Text = i.ToString();
pro.Close();
}
public int Length = 78; // just an estimate, better defined after write() is called
public PDBHeader(string _name, int recCount)
{
DWORD dateNow = makeDate(DateTime.Now);
name = _name;
attributes = 0x08;
version = 0x01;
creationDate = dateNow;
modificationDate = dateNow;
lastBackupDate = dateNow;
modificationNumber = 0x0006;
appInfoID = 0x0000;
sortInfoID = 0x0000;
unqueIDSeed = 0x0000;
nextRecordistID = 0x0000;
numRecords = (ushort)recCount;
}
public static void 音声認識()
{
Task.Run(() =>
{
try
{
word = WORD.NON;//毎回初期化
var wordList = new List <string>();
foreach (var w in Enum.GetValues(typeof(WORD)))
{
wordList.Add(((WORD)w).ToString());
}
State.VmTestStatus.音声認識率 = "音声一致率 ----";
//語彙登録
Choices words = new Choices(wordList.ToArray());
sre.LoadGrammar(new Grammar(new GrammarBuilder(words)));
//入力ソース（既定のマイク）
sre.SetInputToDefaultAudioDevice();//マイクが接続されていないとここで例外が発生する
Flags.FlagStop音声認識 = false;
sre.RecognizeAsync(RecognizeMode.Multiple);//非同期で認識開始
while (true)
{
if (Flags.FlagStop音声認識)
{
sre.RecognizeAsyncCancel();
sre.RecognizeAsyncStop();
break;
}
}
}
catch
{
MessageBox.Show("マイク接続異常\r\nアプリケーションを閉じます");
Environment.Exit(0);
}
finally
{
}
});
}
public Instruction(WORD word)
{
code = word.toShort();
if ((code >> 10) == 0x04)
{
type = InstructionType.SingleOperand;
}
else if ((code >> 13) == 0x01)
{
type = InstructionType.Jump;
}
else
{
type = InstructionType.TwoOperand;
}
}
public bool EqualTokenType(int index, WORD tokenType)
{
try
{
if (TokenList[index].TokenType == tokenType)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public WordMemories(string Code, int Size)
{
if (Size < 1)
{
throw new Exception("Size는 1이상");
}
if (!Regex.IsMatch(Code.ToString(), "[a-zA-Z]", RegexOptions.IgnoreCase))
{
throw new Exception("Code는 알파벳으로");
}
this.RawData = new byte[Size * 2];
this.Code = Code.ToUpper();
W = new WORD[Size];
for (int i = 0; i < W.Length; i++)
{
W[i] = new WORD(this, i * 2);
}
}
int ReceiveData(WORD wDevID, ref BYTE[] pBuf, int nSize, DWORD timeout)
{
WORD wReceivedChkSum, wChkSum;
BYTE[] CommBuf;
int nReceivedBytes;
if (pBuf == null)
{
return(PKT_PARAM_ERR);
}
CommBuf = new BYTE[nSize + HEADER_SIZE + DEV_ID_SIZE + CHK_SUM_SIZE];
nReceivedBytes = serial.Read(CommBuf, 0, nSize + HEADER_SIZE + DEV_ID_SIZE + CHK_SUM_SIZE);
if (nReceivedBytes != nSize + HEADER_SIZE + DEV_ID_SIZE + CHK_SUM_SIZE)
{
return(PKT_COMM_ERR);
}
wReceivedChkSum = (WORD)((WORD)(CommBuf[nSize + HEADER_SIZE + DEV_ID_SIZE + 1] << 0x08) | (WORD)(CommBuf[nSize + HEADER_SIZE + DEV_ID_SIZE]));
if ((CommBuf[0] != DATA_START_CODE1) || (CommBuf[1] != DATA_START_CODE2))
{
return(PKT_HDR_ERR);
}
for (int i = 0; i < nSize; i++)
{
pBuf[i] = CommBuf[i + HEADER_SIZE + DEV_ID_SIZE];
}
wChkSum = CalcChkSumOfDataPkt(ref CommBuf, HEADER_SIZE + DEV_ID_SIZE + nSize);
if (wChkSum != wReceivedChkSum)
{
return(PKT_CHK_SUM_ERR);
}
return(0);
}
// --------------------------------------------------------------------
private static string PluralizeWord(string word)
{
RegexRule[] rules = PLURAL_RULES;
var lword = word.ToLower();
if (!WORD.IsMatch(word) ||
Array.IndexOf(MODALS, lword) > -1)
{
return(word);
}
for (int i = 0; i < rules.Length; i++)
{
if (rules[i].applies(lword))
{
return(rules[i].fire(word));
}
}
return(DEFAULT_PLURAL.fire(word));
}
public CGT511C1(int nPort, int dwBaudrate)
{
//serial = new SerialPort ( "COM"+nPort.ToString() , 9600, Parity.None, 8, StopBits.One);
//uwDevID = DEVICE_ID;
//CommTimeOut = COMM_DEF_TIMEOUT;
//gwLastAck = 0;
//gwLastAckParam = 0;
//serial.ReadTimeout = (int)CommTimeOut;
serial = new SerialPort("COM" + nPort.ToString(), 9600, Parity.None, 8, StopBits.One);
uwDevID = DEVICE_ID;
CommTimeOut = COMM_DEF_TIMEOUT;
gwLastAck = 0;
gwLastAckParam = 0;
serial.ReadTimeout = (int)CommTimeOut;
serial.Open();
change_baudrate(dwBaudrate);
serial.Close();
serial = new SerialPort("COM" + nPort.ToString(), dwBaudrate, Parity.None, 8, StopBits.One);
serial.ReadTimeout = (int)CommTimeOut;
open();
}
int ReceiveCmd(WORD wDevID, ref WORD wCmd, ref int nParam)
{
CMD_PKT pkt;
BYTE[] CommBuf;
int nReceivedBytes;
CommBuf = new BYTE[12];
nReceivedBytes = serial.Read(CommBuf, 0, PKT_SIZE);
if (nReceivedBytes != PKT_SIZE)
{
return(PKT_COMM_ERR);
}
if ((CommBuf[0] != COMMAND_START_CODE1) || (CommBuf[1] != COMMAND_START_CODE2))
{
return(PKT_HDR_ERR);
}
pkt = ByteArrayToPkt(ref CommBuf);
WORD chksum = CalcChkSumOfCmd(ref pkt);
pkt.wChkSum0 = (byte)(chksum % 256);
pkt.wChkSum1 = (byte)(chksum >> 8);
if ((pkt.wChkSum0 != (byte)(chksum % 256)) ||
(pkt.wChkSum1 != (byte)(chksum >> 8)))
{
return(PKT_CHK_SUM_ERR);
}
wCmd = (WORD)(pkt.wCmd1 << 8 | pkt.wCmd0);
nParam = pkt.nParam1 << 8 | pkt.nParam0;
return(0);
}
public WordMemories(string Code, byte[] RawData)
{
if (RawData == null)
{
throw new Exception("RawData는 null일 수 없음");
}
if (RawData.Length % 2 != 0)
{
throw new Exception("RawData의 크기는 2의 배수이어야 함");
}
if (!Regex.IsMatch(Code.ToString(), "[a-zA-Z]", RegexOptions.IgnoreCase))
{
throw new Exception("Code는 알파벳으로");
}
this.RawData = RawData;
this.Code = Code.ToUpper();
W = new WORD[Size];
for (int i = 0; i < W.Length; i++)
{
W[i] = new WORD(this, i * 2);
}
}
public static void set()
{
//イベント登録
sre.SpeechRecognized += async(object sender, SpeechRecognizedEventArgs e) =>
{
if (Busy)
{
return;
}
Busy = true;
try
{
if (e.Result == null)
{
一致率 = 0;
return;
}
一致率 = e.Result.Confidence * 100;
if (一致率 < State.VmTestStatus.VoiceSpec)
{
return;
}
foreach (var w in Enum.GetValues(typeof(WORD)))
{
if (e.Result.Text == ((WORD)w).ToString())
{
word = (WORD)w;
}
}
switch (word)
{
case WORD.オッケー:
case WORD.カイシ:
case WORD.カクニン:
case WORD.スタート:
Flags.OkPushed = true;
break;
case WORD.エヌジー:
case WORD.キャンセル:
Flags.CancelPushed = true;
break;
default:
return;
}
State.VmTestStatus.音声認識率 = $"{ word.ToString()} 一致率{一致率.ToString("F0")}%";
Flags.FlagStopSwCheck = true;
}
finally
{
await Task.Delay(250);
State.VmTestStatus.音声認識率 = "";
Busy = false;
}
};
}
public static bool WriteWORD(IntPtr pOffset, WORD pData)
{
if (processHandle == IntPtr.Zero) {
CheckProcess();
}
try {
return WriteByteArray(pOffset, pData.ToByteArray());
} catch (Exception e) {
if (debugMode) {
Console.WriteLine("Error: WriteWORD: " + e);
}
return false;
}
}
string texName; //纹理名称
public void Load(BinaryReader br)
{
DWORD temp = br.ReadUInt32();
char [] lpName = new char[temp + 1];
char [] strName = br.ReadChars((int)temp);
Array.Copy(strName, lpName, temp);
lpName[temp] = '\0';
this.name = lpName.ToString();
this.dwBlendCount = br.ReadUInt32();
this.dwNVecCount = br.ReadUInt32();
this.dwAVecCount = br.ReadUInt32();
int vertexCount = (int)dwNVecCount + (int)dwAVecCount;
this.vb = new VertexBuffer(Core.Device, vertexCount * VERTERX_SIZE,
Usage.WriteOnly, VertexFormat.None, Pool.Managed);
this.lpVB = new PhyVertex[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
this.lpVB[i] = new PhyVertex(br);
}
DataStream vbs = this.vb.Lock(0, 0, LockFlags.None);
for (int i = 0; i < vertexCount; i++)
{
PhyOutVertex fvf;
fvf.u = this.lpVB[i].u;
fvf.v = this.lpVB[i].v;
fvf.color = this.lpVB[i].color;
}
vbs.Close();
this.vb.Unlock();
this.dwNTriCount = br.ReadUInt32();
this.dwATriCount = br.ReadUInt32();
//三角形个数乘以3即是索引个数
int triCount = (int)this.dwNTriCount + (int)this.dwATriCount;
this.ib = new IndexBuffer(Core.Device, triCount * 3 * 16, Usage.WriteOnly, Pool.Managed, true);
DataStream ibs = this.ib.Lock(0, 0, LockFlags.None);
for (int i = 0; i < triCount * 3; i++)
{
WORD idx = br.ReadUInt16();
ibs.Write <WORD>(idx);
}
ibs.Close();
this.ib.Unlock();
//纹理路径长度
int texNameLen = (int)br.ReadUInt32();
char[] arrTexName = br.ReadChars(texNameLen);
texName = arrTexName.ToString();
int sizeBoxMin = Marshal.SizeOf(typeof(Vector3));
Debug.WriteLine("size:" + sizeBoxMin);
byte[] bytesMin = br.ReadBytes(sizeBoxMin);
GCHandle handle = GCHandle.Alloc(bytesMin, GCHandleType.Pinned);
Vector3 bboxMin = (Vector3)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(Vector3));
handle.Free();
Debug.WriteLine(bboxMin.ToString());
byte[] bytesMax = br.ReadBytes(Vector3.SizeInBytes);
GCHandle handleMax = GCHandle.Alloc(bytesMax, GCHandleType.Pinned);
Vector3 bboxMax = (Vector3)Marshal.PtrToStructure(handleMax.AddrOfPinnedObject(), typeof(Vector3));
handleMax.Free();
}
public static byte LOBYTE(WORD w)
{
return((BYTE)(((DWORD_PTR)(w)) & 0xff)); // WinDef.h:203
}
static void Main(string[] args)
{
try {
string XML = File.ReadAllText(@"lewis.xml");
List <Entry> DICT = compile(XML);
foreach (var WORD in DICT)
{
WORD.correct();
}
Regex[] PATTERNS = Patterns();
var UNK = new StringBuilder();
Dictionary <char, StringBuilder> LINES = new Dictionary <char, StringBuilder>();
foreach (var WORD in DICT)
{
Regex found = null;
foreach (Regex REX in PATTERNS)
{
if (REX.IsMatch(WORD.Declaration))
{
System.Diagnostics.Debug.Assert(found == null, "Duplicate regular expression pattern detected.");
found = REX;
}
}
if (found != null)
{
char c = char.ToLowerInvariant(WORD.Declaration[0]);
if (c == '(')
{
c = WORD.Declaration[1];
}
switch (c)
{
case 'ā':
c = 'a';
break;
case 'ē':
c = 'e';
break;
case 'ō':
c = 'o';
break;
case 'ī':
c = 'i';
break;
case 'ū':
c = 'u';
break;
}
c = char.ToUpperInvariant(c);
if (!LINES.ContainsKey(c))
{
LINES[c] = new StringBuilder();
}
LINES[c].Append($"##### {WORD.Declaration}");
if (!string.IsNullOrWhiteSpace(WORD.Definition))
{
LINES[c].Append($"\r\n{WORD.Definition}");
}
LINES[c].Append($"\r\n");
}
else
{
UNK.Append($"##### {WORD.Declaration}\r\n");
}
}
foreach (var c in LINES)
{
if (c.Value != null)
{
File.WriteAllText($"data//{c.Key}.md", c.Value.ToString());
}
}
File.WriteAllText(@"lewis.md", UNK.ToString());
} catch (Exception e) {
Console.Error?.WriteLine(e);
}
Console.WriteLine("Done.");
}
public static int writeWord(byte[] bytes, int offset, WORD val)
{
return(writeUshort(bytes, offset, (ushort)val));
}
virtual HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
return(E_NOTIMPL);
}
private static FIELD CreateNewField(BinaryReader br, int index, int fieldOffset, int dataOrDataOffset, GffFieldType fieldType)
{
FIELD data;
switch (fieldType)
{
case GffFieldType.BYTE:
data = new BYTE(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CHAR:
data = new CHAR(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.WORD:
data = new WORD(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.SHORT:
data = new SHORT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DWORD:
data = new DWORD(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.INT:
data = new INT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DWORD64:
data = new DWORD64(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.INT64:
data = new INT64(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.FLOAT:
data = new FLOAT(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.DOUBLE:
data = new DOUBLE(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CExoString:
data = new CExoString(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.ResRef:
data = new ResRef(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.CExoLocString:
data = new CExoLocString(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.VOID:
data = new VOID(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Struct:
int lbl_index = br.ReadInt32();
data = new STRUCT(br, br.ReadInt32(), lbl_index);
break;
case GffFieldType.List:
data = new LIST(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Orientation:
data = new Orientation(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.Vector:
data = new Vector(br, fieldOffset + dataOrDataOffset * 12);
break;
case GffFieldType.StrRef:
data = new StrRef(br, fieldOffset + dataOrDataOffset * 12);
break;
default:
throw new Exception(string.Format("UNEXPECTED FIELD TYPE \"{0}\", IN STRUCT INDEX \"{1}\"", fieldType, index));
}
return(data);
}
public void Reverse_WithWordString_ExpectsReversedWordString()
=> Equal(
WORD_REVERSED,
WORD.Reverse());
public void writeWord(WORD value, ushort address)
{
data[address] = value.low;
data[address + 1] = value.high;
}
static void NE_FixupSegmentPrologs(NE_MODULE* pModule, WORD segnum)
{
SEGTABLEENTRY* pSegTable = NE_SEG_TABLE(pModule);
ET_BUNDLE* bundle;
ET_ENTRY* entry;
WORD dgroup, num_entries, sel = SEL(pSegTable[segnum - 1].hSeg);
BYT* pSeg, *pFunc;
if (pSegTable[segnum - 1].flags & NE_SEGFLAGS_DATA)
{
pSegTable[segnum - 1].flags |= NE_SEGFLAGS_LOADED;
return;
}
if (!pModule->ne_autodata) return;
if (!pSegTable[pModule.ne_autodata - 1].hSeg) return;
dgroup = SEL(pSegTable[pModule.ne_autodata - 1].hSeg);
pSeg = MapSL(MAKESEGPTR(sel, 0));
bundle = (ET_BUNDLE*)((BYTE*)pModule + pModule.ne_enttab);
do {
Debug.Print("num_entries: {0}, bundle: {1}, next: {2:X4}, pSeg: {3}", bundle.last - bundle.first, bundle, bundle.next, pSeg);
if (!(num_entries = bundle.last - bundle.first))
return;
entry = (ET_ENTRY*)((BYTE*)bundle + 6);
while (num_entries--)
{
/*TRACE("entry: %p, entry.segnum: %d, entry.offs: %04x\n", entry, entry.segnum, entry.offs);*/
if (entry.segnum == segnum)
{
pFunc = pSeg + entry.offs;
TRACE("pFunc: %p, *(DWORD *)pFunc: %08x, num_entries: %d\n", pFunc, *(DWORD*)pFunc, num_entries);
if (*(pFunc + 2) == 0x90)
{
if (*(WORD*)pFunc == 0x581e) /* push ds, pop ax */
{
TRACE("patch %04x:%04x -> mov ax, ds\n", sel, entry.offs);
*(WORD*)pFunc = 0xd88c; /* mov ax, ds */
}
if (*(WORD*)pFunc == 0xd88c)
{
if ((entry.flags & 2)) /* public data ? */
{
TRACE("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry.offs, dgroup);
*pFunc = 0xb8; /* mov ax, */
*(WORD*)(pFunc + 1) = dgroup;
}
else if ((pModule.ne_flags & NE_FFLAGS_MULTIPLEDATA)
&& (entry.flags & 1)) /* exported ? */
{
TRACE("patch %04x:%04x -> nop, nop\n", sel, entry.offs);
*(WORD*)pFunc = 0x9090; /* nop, nop */
}
}
}
}
entry++;
}
} while ((bundle.next) && (bundle = ((ET_BUNDLE*)((BYTE*)pModule + bundle.next))));
}
static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
{
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE(pModule);
ET_BUNDLE * bundle;
ET_ENTRY * entry;
WORD dgroup, num_entries, sel = SEL(pSegTable[segnum - 1].hSeg);
BYT * pSeg, *pFunc;
if (pSegTable[segnum - 1].flags & NE_SEGFLAGS_DATA)
{
pSegTable[segnum - 1].flags |= NE_SEGFLAGS_LOADED;
return;
}
if (!pModule->ne_autodata)
{
return;
}
if (!pSegTable[pModule.ne_autodata - 1].hSeg)
{
return;
}
dgroup = SEL(pSegTable[pModule.ne_autodata - 1].hSeg);
pSeg = MapSL(MAKESEGPTR(sel, 0));
bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule.ne_enttab);
do
{
Debug.Print("num_entries: {0}, bundle: {1}, next: {2:X4}, pSeg: {3}", bundle.last - bundle.first, bundle, bundle.next, pSeg);
if (!(num_entries = bundle.last - bundle.first))
{
return;
}
entry = (ET_ENTRY *)((BYTE *)bundle + 6);
while (num_entries--)
{
/*TRACE("entry: %p, entry.segnum: %d, entry.offs: %04x\n", entry, entry.segnum, entry.offs);*/
if (entry.segnum == segnum)
{
pFunc = pSeg + entry.offs;
TRACE("pFunc: %p, *(DWORD *)pFunc: %08x, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
if (*(pFunc + 2) == 0x90)
{
if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
{
TRACE("patch %04x:%04x -> mov ax, ds\n", sel, entry.offs);
*(WORD *)pFunc = 0xd88c; /* mov ax, ds */
}
if (*(WORD *)pFunc == 0xd88c)
{
if ((entry.flags & 2)) /* public data ? */
{
TRACE("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry.offs, dgroup);
*pFunc = 0xb8; /* mov ax, */
*(WORD *)(pFunc + 1) = dgroup;
}
else if ((pModule.ne_flags & NE_FFLAGS_MULTIPLEDATA) &&
(entry.flags & 1)) /* exported ? */
{
TRACE("patch %04x:%04x -> nop, nop\n", sel, entry.offs);
*(WORD *)pFunc = 0x9090; /* nop, nop */
}
}
}
}
entry++;
}
} while ((bundle.next) && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle.next))));
}
protected virtual void FixupILCode(ILBuffer current, OpCode qcode, int argFixOffset, bool hasReturn)
{
// ldarg.s -> stloc.s
// 0xE ~ 0x13
// + FDFB = long version (remove 's')
WORD v = qcode.Value;
if (Range(v, 0xE, 0x13))
{
v += 0xFD_FB;
// fix operand size
current.operand = (short)(byte)current.operand;
}
// (only return buffer, instance)
if (argFixOffset == 2)
{
// ldarg_3
if (v == 5)
{
v = 0xFE_09; // ldarg
current.operand = (short)4;
}
// ldarg_1 ldarg_2
else if (v == 3 || v == 4)
{
v++;
}
// ldarg ldarga starg
else if (Range(v, 0xFE_09, 0xFE_0B))
{
current.operand = (short)((short)current.operand + 1);
}
}
if (hasReturn)
{
// ldloc_3
if (v == 9)
{
v = 0xFE_0C; // ldloc
current.operand = (short)4;
}
// stloc_3
else if (v == 0xD)
{
v = 0xFE_0E;
current.operand = (short)4;
}
// ldloc_0 ldloc_1 ldloc_2 stloc_0 stloc_1 stloc_2
else if (Range(v, 6, 8) || Range(v, 0xA, 0xD))
{
v++;
}
// ldloc ldloca stloc
else if (Range(v, 0xFE_0C, 0xFE_0E))
{
current.operand = (short)((short)current.operand + 1);
}
}
// br.s -> blt.un.s
if (Range(v, 0x2B, 0x37))
{
v += 0xD;
}
else if (v == 0xDE) // leave.s
{
v = 0xDD;
}
if (v != qcode.Value)
{
current.code = OpCodeConverter.GetCode(v.unsigned);
}
}
