private _event: EventEmitter;

constructor() {

this._event = new EventEmitter();

}

notify() {

this._event.emit('done');

}

async wait(): Promise<void> {

return new Promise((resolve) => {

this._event.once('done', () => {

resolve();

});

});

}

name: string;

bitsOffset: number;

bitsWidth: number;

name: string;

baseAddress?: string;

bytes: number;

fields?: RegisterField[];

name: string;

baseAddress: string;

registers: PeriphRegister[];

SCOPE_GLOBAL = 1, // ID must > 0

SCOPE_LOCAL,

SCOPE_FUNC_PARAMS,

SCOPE_REGISTER,

SCOPE_OPTION_BYTES,

SCOPE_PERIPHERAL

// must bigger than Scope ID

private static readonly HANLER_START: number = 10;

private static readonly HANLER_NULL: number = -1;

private readonly ThreadID = 1;

private gdb: GDB;

private cwd: File;

private configDoneEmitter: Subject = new Subject();

private isConnected: boolean = false;

private stringAsArray: boolean;

private useSyncMode: boolean = false;

private globalVars: string[] = [];

private vHandles: Handles<Variable[]>;

private rootVariables: Map<ScopeType, Variable[]> = new Map();

private periphReferanceMap: Map<number, string> = new Map();

private peripherals: Peripheral[] = [];

private periphRegValueMap: Map<string, number> = new Map();

// current frame information

private frameChanged = false;

private funcArguments: IGDB.Variable[] = [];

private bpMap: Map<string, IGDB.Breakpoint[]> = new Map();

private preLoadBPMap: Map<string, IGDB.Breakpoint[]> = new Map();

private timeUsed: number | undefined;

// disassembly document

disassemblyScheme: string;

assemblyMatcher = {

'normal': /^(0x[0-9a-f]+)\s+(<[^>]+>:)\s+(?:0x[0-9a-f]+)\s+(.*?)\s*$/i,

'simple': /^(0x[0-9a-f]+):\s+(?:0x[0-9a-f]+)\s+(.*?)\s*$/i

};

disassemblyBuf: Map<string, string[]>;

assemblyTextEvent: vscode.EventEmitter<vscode.Uri>;

onDidChange: vscode.Event<vscode.Uri>;

constructor() {

super();

this.vHandles = new Handles(DebugAdapter.HANLER_START);

this.cwd = <File>ResourceManager.getInstance().getWorkspaceDir();

this.gdb = new GDB(ResourceManager.getInstance().isVerboseMode());

this.stringAsArray = ResourceManager.getInstance().isParseString2Array();

this.disassemblyScheme = ResourceManager.getInstance().getAppName();

this.assemblyTextEvent = new vscode.EventEmitter();

this.onDidChange = this.assemblyTextEvent.event;

this.disassemblyBuf = new Map();

this.setDebuggerColumnsStartAt1(false);

this.setDebuggerLinesStartAt1(false);

this.gdb.on('log', (logData) => {

switch (logData.type) {

case 'warning':

this.warn(logData.msg);

break;

case 'error':

this.error(logData.msg);

break;

default:

this.log(logData.msg);

break;

}

});

}

private log(line: string) {

this.sendEvent(new OutputEvent(`${line}\r\n`, 'stdout'));

}

private warn(line: string) {

this.sendEvent(new OutputEvent(`${line}\r\n`));

}

private error(line: string) {

this.sendEvent(new OutputEvent(`${line}\r\n`, 'stderr'));

}

//----- variables

private cacheChild(children: IGDB.VariableChildren): number {

return this.vHandles.create(children.map((item) => {

const vTemp = new Variable(item.name, '', DebugAdapter.HANLER_NULL);

switch (item.type) {

case 'array':

vTemp.value = `array [${(<any[]>item.value).length}]`;

vTemp.variablesReference = this.cacheChild(<IGDB.VariableChildren>item.value);

break;

case 'obj':

vTemp.value = 'struct {...}';

vTemp.variablesReference = this.cacheChild(<IGDB.VariableChildren>item.value);

break;

default:

vTemp.value = <string>item.value;

break;

}

return vTemp;

}));

}

private vClearAll() {

this.vHandles.reset();

}

private vToVariable(_var: IGDB.Variable): Variable {

const result: DebugProtocol.Variable = new Variable(_var.name, '', DebugAdapter.HANLER_NULL);

switch (_var.type) {

case 'array':

result.value = `array [${(<any[]>_var.value).length}]`;

result.variablesReference = this.cacheChild(<IGDB.VariableChildren>_var.value);

break;

case 'obj':

result.value = 'struct {...}';

result.variablesReference = this.cacheChild(<IGDB.VariableChildren>_var.value);

break;

case 'string':

{

const value: string = <string>_var.value;

result.value = `"${value}"`;

result.type = _var.type;

// conver a string to an array

if (this.stringAsArray) {

const cArr = Array.from(value).map((_char, index) => {

return <IGDB.Variable>{

name: index.toString(),

type: 'integer',

value: _char.charCodeAt(0).toString()

};

});

// add '\0' suffix

cArr.push({

name: cArr.length.toString(),

type: 'integer',

value: '0'

});

result.variablesReference = this.cacheChild(cArr);

}

}

break;

default:

result.value = <string>_var.value;

result.type = _var.type;

break;

}

return result;

}

private vGetChildren(ref: number): Variable[] {

return this.vHandles.get(ref, []);

}

private vGetRoot(name: string): Variable | undefined {

for (const rootList of this.rootVariables.values()) {

const index = rootList.findIndex((v) => { return v.name === name; });

if (index !== -1) {

return rootList[index];

}

}

return undefined;

}

//------ source

private createSource(_path: string): Source {

if (NodePath.isAbsolute(_path)) {

return new Source(NodePath.basename(_path), _path);

} else {

const absPath = NodePath.join(this.cwd.path, _path);

return new Source(NodePath.basename(absPath), absPath);

}

}

private toRelative(_path: string): string {

return _path;

}

private async loadBreakPoints() {

for (const keyValue of this.preLoadBPMap) {

const fPath = keyValue[0];

const bpList = keyValue[1];

const validList: IGDB.Breakpoint[] = [];

for (const bp of bpList) {

const bkpt = await this.gdb.addBreakPoint(bp);

if (bkpt) {

validList.push(bkpt);

/* this.sendEvent(new BreakpointEvent('changed',

}

}

this.bpMap.set(fPath, validList);

}

this.preLoadBPMap.clear();

}

//------ svd

private loadSvd(fPath: string) {

const svdFile = new File(fPath);

if (!svdFile.IsFile()) {

throw new Error(`not found file: ${svdFile.path}`);

}

try {

this.peripherals = <Peripheral[]>JSON.parse(svdFile.Read());

} catch (e) {

throw new Error(`incorrect json file format: ${(<Error>e).message}`);

}

try {

// check data format

this.peripherals.forEach((periph, index) => {

if (typeof periph.name !== 'string') {

throw new Error(`'name' must be a string, peripheral index: ${index}`);

}

if (typeof periph.baseAddress !== 'string') {

throw new Error(`'baseAddress' must be a string, at peripheral: ${periph.name}`);

}

if (!Array.isArray(periph.registers)) {

throw new Error(`'registers' must be a array, at peripheral: ${periph.name}`);

}

let baseAddress = parseInt(periph.baseAddress);

let offset = 0;

periph.registers.forEach((reg, rIndex) => {

if (typeof reg.name !== 'string') {

throw new Error(`'name' must be a string, at peripheral: ${periph.name}, register index: ${rIndex}`);

}

if (typeof reg.bytes !== 'number') {

throw new Error(`'bytes' must be a number, at peripheral: ${periph.name}, register: ${reg.name}`);

}

if (typeof reg.baseAddress !== 'string' && typeof reg.baseAddress !== 'undefined') {

throw new Error(`'baseAddress' must be string or undefined, at peripheral: ${periph.name}, register: ${reg.name}`);

}

if (!Array.isArray(reg.fields) && typeof reg.fields !== 'undefined') {

throw new Error(`'fields' must be array or undefined, at peripheral: ${periph.name}, register: ${reg.name}`);

}

if (reg.fields) {

reg.fields.forEach((field) => {

if (typeof field.name !== 'string') {

throw new Error(`'fields' format error, at peripheral: ${periph.name}, register: ${reg.name}`);

}

if (typeof field.bitsOffset !== 'number') {

throw new Error(`'fields' format error, at peripheral: ${periph.name}, register: ${reg.name}`);

}

if (typeof field.bitsWidth !== 'number') {

throw new Error(`'fields' format error, at peripheral: ${periph.name}, register: ${reg.name}`);

}

});

}

// fill register address

if (reg.baseAddress) {

baseAddress = parseInt(reg.baseAddress);

offset = 1;

} else {

reg.baseAddress = `0x${(baseAddress + offset).toString(16)}`;

offset++;

}

});

});

} catch (error) {

this.peripherals = [];

throw error;

}

}

private getSVDFilter(): SvdFilter[] {

return ResourceManager.getInstance()

.getSvdDir().GetList([/\.svd\.json$/], File.EMPTY_FILTER)

.map((file) => {

const cpuName = file.name.split('.')[0];

return {

file: file,

regexp: new RegExp(`^${cpuName}`, 'i')

};

});

}

private periphToVariables(): Variable[] {

// clear ptr map, value cache

this.periphReferanceMap.clear();

this.periphRegValueMap.clear();

return this.peripherals.map((periph) => {

const vPeriph = new Variable(`${periph.name}`,

`address ${periph.baseAddress}`, DebugAdapter.HANLER_NULL);

vPeriph.vPath = periph.name;

vPeriph.variablesReference = this.vHandles.create(periph.registers.map((register) => {

const vReg = new Variable(register.name, 'null', DebugAdapter.HANLER_NULL);

vReg.vPath = `${vPeriph.vPath}.${register.name}`;

const children = register.fields?.map((field) => {

const vField = new Variable(field.name, 'null', DebugAdapter.HANLER_NULL);

vField.vPath = `${vReg.vPath}.${field.name}`;

return vField;

});

if (children) {

vReg.variablesReference = this.vHandles.create(children);

// add ptr to mapper

this.periphReferanceMap.set(vReg.variablesReference, vReg.vPath);

}

return vReg;

}));

// add ptr to mapper

this.periphReferanceMap.set(vPeriph.variablesReference, vPeriph.vPath);

return vPeriph;

});

}

private isPeriphRef(ref: number): boolean {

return this.periphReferanceMap.has(ref);

}

private getPeriphByPath(vPath: string): Peripheral | PeriphRegister | RegisterField | undefined {

const nameList = vPath.split('.');

// search peripheral

if (nameList.length > 0) {

const pIndex = this.peripherals.findIndex((periph) => { return periph.name === nameList[0]; });

if (pIndex !== -1) {

const periph = this.peripherals[pIndex];

// search register

if (nameList.length > 1) {

const regIndex = periph.registers.findIndex((reg) => { return reg.name === nameList[1]; });

if (regIndex !== -1) {

const register = periph.registers[regIndex];

// search fields

if (nameList.length > 2) {

if (register.fields) {

const fIndex = register.fields.findIndex((field) => { return field.name === nameList[2]; });

if (fIndex !== -1) {

return register.fields[fIndex];

}

}

} else {

return register;

}

}

} else {

return periph;

}

}

}

}

private async readPeriphRegisters(ref: number): Promise<Variable[]> {

const resultList: Variable[] = [];

const reqList: Variable[] = this.vHandles.get(ref, []);

for (const reqVar of reqList) {

if (reqVar.vPath) {

const nameList = reqVar.vPath.split('.');

// is registers

if (nameList.length === 2) {

const register = <PeriphRegister>this.getPeriphByPath(reqVar.vPath);

if (register) {

const baseAddress = parseInt(<string>register.baseAddress);

const mem = await this.gdb.readMemory(baseAddress, register.bytes);

// check address, length

if (mem.addr === baseAddress &&

mem.buf.length === register.bytes) {

// set value

if (mem.buf.length === 1) {

reqVar.value = `0x${mem.buf[0].toString(16)}`;

// cache

this.periphRegValueMap.set(reqVar.vPath, mem.buf[0]);

} else {

const hexList = mem.buf.map((num) => { return `0x${num.toString(16)}`; });

reqVar.value = `[${hexList.join(',')}]`;

}

} else {

// clear cache

this.periphRegValueMap.delete(reqVar.vPath);

}

}

resultList.push(reqVar);

}

// is fields

else if (nameList.length === 3) {

const regValue = this.periphRegValueMap.get(`${nameList[0]}.${nameList[1]}`);

const field = <RegisterField>this.getPeriphByPath(reqVar.vPath);

if (field && typeof regValue !== 'undefined') {

let mask = 0; // bit mask

for (let i = 0; i < field.bitsWidth; i++) {

mask = (mask << 1) | 1;

}

const fieldValue = (regValue >> field.bitsOffset) & mask;

reqVar.value = `0x${fieldValue.toString(16)}`;

resultList.push(reqVar);

}

}

}

}

return resultList;

}

//----- disassembly

private async disassembleRange(start: string, length: string): Promise<string[] | undefined> {

const lines = await this.gdb.readDisassembly({

start: start,

length: length

});

if (lines) {

return lines;

}

}

private splitInstructionLine(line: string): { instruction: string, comment: string } | undefined {

const wsIndex = line.search(/\s/);

if (wsIndex !== -1) {

const instName = line.substring(0, wsIndex);

const nInstIndex = line.indexOf(instName, wsIndex);

if (nInstIndex !== -1) {

return {

instruction: line.substring(0, nInstIndex).trim(),

comment: line.substring(nInstIndex).trim()

};

}

}

}

provideTextDocumentContent(uri: vscode.Uri, token: vscode.CancellationToken): vscode.ProviderResult<string> {

const lines = this.disassemblyBuf.get(uri.toString());

if (lines) {

const resList: { addr: string, txt: string, inst: string, com: string }[] = [];

let maxTextLen: number = 0;

let maxInstLen: number = 0;

lines.forEach((line) => {

/**

let mList = this.assemblyMatcher['normal'].exec(line);

if (mList && mList.length > 3) {

const pair = this.splitInstructionLine(mList[3]);

if (pair) {

// add line

maxInstLen = pair.instruction.length > maxInstLen ? pair.instruction.length : maxInstLen;

maxTextLen = mList[2].length > maxTextLen ? mList[2].length : maxTextLen;

resList.push({ addr: mList[1], txt: mList[2], inst: pair.instruction, com: pair.comment });

return;

}

// add line

maxTextLen = mList[2].length > maxTextLen ? mList[2].length : maxTextLen;

resList.push({ addr: mList[1], txt: mList[2], inst: mList[3], com: '' });

return;

}

/**

mList = this.assemblyMatcher['simple'].exec(line);

if (mList && mList.length > 2) {

const pair = this.splitInstructionLine(mList[2]);

if (pair) {

maxInstLen = pair.instruction.length > maxInstLen ? pair.instruction.length : maxInstLen;

resList.push({ addr: mList[1], txt: '', inst: pair.instruction, com: pair.comment });

return;

}

// add line

resList.push({ addr: mList[1], txt: '', inst: mList[2], com: '' });

return;

}

// add line

resList.push({ addr: line, txt: '', inst: '', com: '' });

return;

});

// convert line

return resList.map((info) => {

return `${info.addr}\t${info.txt.padEnd(maxTextLen)}\t${info.inst.padEnd(maxInstLen)}\t; ${info.com}`;

}).join('\r\n');

}

}

//------ option bytes

//command gdi mcuoption -show

private async readOptionBytes(): Promise<IGDB.Variable[] | undefined> {

// sdcc not support read option bytes

if (this.gdb.getAdapter().type === 'stm8-sdcc') {

return undefined;

}

const result = await this.gdb.sendCustomCommand('gdi mcuoption -show');

if (result.resultType === 'done') {

const vList: IGDB.Variable[] = [];

result.lines.forEach((line) => {

const index = line.indexOf(':');

if (index !== -1) {

vList.push({

name: line.substr(0, index),

type: 'orignal',

value: line.substr(index + 1)

});

}

});

return vList;

}

}

//=================================================

/**

protected async initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments) {

// build and return the capabilities of this debug adapter:

response.body = response.body || {};

response.body.supportsConfigurationDoneRequest = true;

response.body.supportsEvaluateForHovers = true;

response.body.supportsConditionalBreakpoints = true;

response.body.supportsRestartRequest = true;

//response.body.supportsTerminateRequest = true;

this.sendResponse(response);

this.sendEvent(new InitializedEvent());

}

protected async terminateRequest(response: DebugProtocol.TerminateResponse, args: DebugProtocol.TerminateArguments, request?: DebugProtocol.Request) {

}

protected disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments) {

this.log('[SEND]: kill gdb.exe');

this.gdb.kill().then(() => {

this.log('\tdone');

this.log('[END]');

this.isConnected = false;

GlobalEvent.emit('debug.terminal');

this.sendResponse(response);

});

}

/**

protected configurationDoneRequest(response: DebugProtocol.ConfigurationDoneResponse, args: DebugProtocol.ConfigurationDoneArguments): void {

super.configurationDoneRequest(response, args);

// notify the launchRequest that configuration has finished

setTimeout(() => {

this.configDoneEmitter.notify();

}, 100);

}

protected async launchRequest(response: DebugProtocol.LaunchResponse, args: LaunchArguments) {

// wait until configuration has finished (and configurationDoneRequest has been called)

await this.configDoneEmitter.wait();

// init

this.log(`==================== Initialize ====================\r\n`);

const adpTag: IGDB.GdbServerType = args.serverType || 'st7';

// st7 not support async mode

this.useSyncMode = adpTag === 'st7';

// get gdb adapter by tag

const adapter = getAdapter(adpTag);

if (adapter === undefined) {

this.error(`Not found gdb adapter: '${adpTag}'`);

this.sendEvent(new TerminatedEvent()); // launch failed, exit

return;

}

this.gdb.initAdapter(adapter);

// launch gdb.exe process

const errMsg = await this.gdb.launch([

`--quiet`,

`--cd=${this.cwd.path}`,

`--directory=${this.cwd.path}`

]);

if (errMsg) {

this.error(errMsg);

this.sendEvent(new TerminatedEvent()); // launch failed, exit

return;

}

// load svd

try {

if (args.svdFile) {

const absPath: string = NodePath.isAbsolute(args.svdFile)

? args.svdFile : NodePath.normalize(`${this.cwd.path}${File.sep}${args.svdFile}`);

this.log(`Load SVD: ${args.svdFile}`);

this.loadSvd(absPath);

} else {

const filters = this.getSVDFilter();

const index = filters.findIndex((item) => { return item.regexp.test(args.cpu); });

if (index !== -1) {

this.log(`Load SVD: ${filters[index].file.name}`);

this.loadSvd(filters[index].file.path);