skyeye-sdk-js 1.1.1 → 1.1.3

package/src/SkyEyeClient.js

@@ -0,0 +1,1272 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkyEyeClient = void 0;
+var grpc = require("@grpc/grpc-js");
+var skyeye_rpc_pb_1 = require("./proto/skyeye_rpc_pb");
+var skyeye_rpc_grpc_pb_1 = require("./proto/skyeye_rpc_grpc_pb");
+var RequestFactory_1 = require("./RequestFactory");
+var GetCpuListResponse_1 = require("./response/GetCpuListResponse");
+var Cpu_1 = require("./models/Cpu");
+var GetDeviceListResponse_1 = require("./response/GetDeviceListResponse");
+var GetRunningStateResponse_1 = require("./response/GetRunningStateResponse");
+var Register_1 = require("./models/Register");
+var GetDeviceTreeResponse_1 = require("./response/GetDeviceTreeResponse");
+var ParseBoardUtils_1 = require("./utils/ParseBoardUtils");
+var GetAllDeviceInfoResponse_1 = require("./response/GetAllDeviceInfoResponse");
+var GetRamAddrInfoResponse_1 = require("./response/GetRamAddrInfoResponse");
+var Device_1 = require("./models/Device");
+var FaultInjectType_1 = require("./models/FaultInjectType");
+var FaultInjectItem_1 = require("./models/FaultInjectItem");
+var GetFaultInjectListResponse_1 = require("./response/GetFaultInjectListResponse");
+var GetDisassembleInfoResponse_1 = require("./response/GetDisassembleInfoResponse");
+var InstructionItem_1 = require("./models/InstructionItem");
+var GetCpuRegisterInfoResponse_1 = require("./response/GetCpuRegisterInfoResponse");
+var SkyEyeSDKException_1 = require("./exception/SkyEyeSDKException");
+var cp = require("child_process");
+var client = null;
+// ----------------------------当前运行程序的设备树----------------------------------------//
+var boardMap = new Map();
+var SkyEyeClient = /** @class */ (function (_super) {
+    __extends(SkyEyeClient, _super);
+    function SkyEyeClient(host, port) {
+        var _this = _super.call(this, host + ":" + port, grpc.credentials.createInsecure(), null) || this;
+        _this.host = host;
+        _this.port = port;
+        return _this;
+    }
+    SkyEyeClient.prototype.RunTestcase = function (json) {
+        return __awaiter(this, void 0, void 0, function () {
+            var request, stream;
+            return __generator(this, function (_a) {
+                try {
+                    request = new skyeye_rpc_pb_1.JSONRequest();
+                    request.setRequest(json);
+                    stream = _super.prototype.runTestcase.call(this, request);
+                    return [2 /*return*/, stream];
+                }
+                catch (error) {
+                    console.error("Error during RunTestcase:", error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SkyEyeClient.prototype.Monitor = function (json) {
+        return __awaiter(this, void 0, void 0, function () {
+            var request, stream;
+            return __generator(this, function (_a) {
+                try {
+                    request = new skyeye_rpc_pb_1.JSONRequest();
+                    request.setRequest(json);
+                    stream = _super.prototype.Monitor.call(this, request);
+                    return [2 /*return*/, stream];
+                }
+                catch (error) {
+                    console.error("Error during RunTestcase:", error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SkyEyeClient.prototype.call = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, ackObj, error_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        this.printRequestLog(request);
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                _super.prototype.callSkyEye.call(_this, request, function (error, response) {
+                                    if (error) {
+                                        reject(error);
+                                    }
+                                    else {
+                                        resolve(response);
+                                    }
+                                });
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        ackObj = JSON.parse(response.toString()).ack;
+                        this.printResponseLog(ackObj);
+                        return [2 /*return*/, ackObj];
+                    case 2:
+                        error_1 = _a.sent();
+                        console.error("Error during gRPC call:", error_1);
+                        throw error_1;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.printRequestLog = function (request) {
+        if (request.getRequest() != null) {
+            var base = JSON.parse(request.getRequest());
+            if (base.request.name === "SE_get_running_status" || base.request.name === "SE_get_all_class_info") {
+                return;
+            }
+            console.log("客户端请求-- ", JSON.stringify(base));
+        }
+    };
+    SkyEyeClient.prototype.printResponseLog = function (ackObj) {
+        if (ackObj != null) {
+            var name_1 = ackObj.name;
+            if (name_1 === "SE_get_running_status" || name_1 === "SE_get_all_class_info") {
+                return;
+            }
+            console.log("\u5BA2\u6237\u7AEF\u54CD\u5E94-- ", ackObj);
+        }
+    };
+    SkyEyeClient.prototype.runScriptRequest = function (filename) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().runScriptRequest(filename))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_2 = _a.sent();
+                        console.error("Error during runScriptRequest:", error_2);
+                        throw error_2;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.runCommand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().runCommand())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_3 = _a.sent();
+                        console.error("Error during runCommand:", error_3);
+                        throw error_3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.stopCommand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().stopCommand())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_4 = _a.sent();
+                        console.error("Error during stopCommand:", error_4);
+                        throw error_4;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.quitCommand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().quitCommand())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_5 = _a.sent();
+                        console.error("Error during quitCommand:", error_5);
+                        throw error_5;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCpuList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, cpuItems_1, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetCpuListResponse_1.GetCpuListResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getCpuList())];
+                    case 2:
+                        call = _a.sent();
+                        if (call != null) {
+                            response.isSuccess = true;
+                            if (call.result != null) {
+                                cpuItems_1 = new Array();
+                                call.result.forEach(function (element) {
+                                    var item = new Cpu_1.Cpu(null);
+                                    if (element.classname) {
+                                        item.setClassName(element.classname);
+                                    }
+                                    if (element.objname) {
+                                        item.setName(element.objname);
+                                    }
+                                    if (element.mach) {
+                                        if (boardMap.has(String(element.mach))) {
+                                            item.setParent(boardMap.get(String(element.mach)));
+                                        }
+                                    }
+                                    cpuItems_1.push(item);
+                                });
+                                response.setCpuList(cpuItems_1);
+                            }
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [2 /*return*/, response];
+                    case 3:
+                        error_6 = _a.sent();
+                        console.error("Error during getCpuList:", error_6);
+                        throw error_6;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.enableDeviceWork = function (deviceName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().enableDeviceWork(deviceName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_7 = _a.sent();
+                        console.error("Error during enableDeviceWork:", error_7);
+                        throw error_7;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.disableDeviceWork = function (deviceName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().disableDeviceWork(deviceName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_8 = _a.sent();
+                        console.error("Error during disableDeviceWork:", error_8);
+                        throw error_8;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.changeDir = function (skyeyeProjectRootDir) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().changeDir(skyeyeProjectRootDir))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_9 = _a.sent();
+                        console.error("Error during changeDir:", error_9);
+                        throw error_9;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getRunningDeviceInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_10;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getRunningDeviceInfo())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_10 = _a.sent();
+                        console.error("Error during getRunningDeviceInfo:", error_10);
+                        throw error_10;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getSimulationTime = function (cpuName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_11;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getSimulationTime(cpuName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_11 = _a.sent();
+                        console.error("Error during getCurrentSimulationTime:", error_11);
+                        throw error_11;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCurrentSimulationTime = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (cpuList.length > 0) {
+                            return [2 /*return*/, this.getSimulationTime(cpuList[0].getName())];
+                        }
+                        else {
+                            console.error("无法获取cpu，请确认cpu是否存在:");
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getDeviceList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, result, objectNode, it, _i, it_1, machine, machName, devices, deviceNames, _a, deviceNames_1, deviceName, device, items, error_12;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        response = new GetDeviceListResponse_1.GetDeviceListResponse();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getDeviceList())];
+                    case 2:
+                        call = _b.sent();
+                        console.log("getDeviceList:", call);
+                        if (call != null) {
+                            response.isSuccess = true;
+                            result = call.result;
+                            if (typeof result === 'object' && result !== null) {
+                                objectNode = result;
+                                it = Object.entries(objectNode);
+                                for (_i = 0, it_1 = it; _i < it_1.length; _i++) {
+                                    machine = it_1[_i];
+                                    machName = machine[0];
+                                    devices = machine[1];
+                                    if (typeof devices === 'object' && devices !== null) {
+                                        deviceNames = Object.keys(devices);
+                                        for (_a = 0, deviceNames_1 = deviceNames; _a < deviceNames_1.length; _a++) {
+                                            deviceName = deviceNames_1[_a];
+                                            device = new Device_1.Device(null);
+                                            items = devices[deviceName];
+                                            device.name = deviceName;
+                                            if (boardMap.has(machName)) {
+                                                device.parent = boardMap.get(machName);
+                                            }
+                                            if (items && items.hasOwnProperty("classname")) {
+                                                device.className = items["classname"];
+                                            }
+                                            response.deviceList.push(device);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_12 = _b.sent();
+                        console.error("Error during getPC:", error_12);
+                        throw error_12;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getPC = function (cpuName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_13;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getCurrentPC(cpuName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_13 = _a.sent();
+                        console.error("Error during getPC:", error_13);
+                        throw error_13;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCurrentPC = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_14;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getCurrentPC(cpuList[0].getName()))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_14 = _a.sent();
+                        console.error("Error during getCurrentPC:", error_14);
+                        throw error_14;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCpuMips = function (cpuName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_15;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getCpuMips(cpuName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_15 = _a.sent();
+                        console.error("Error during getCpuMips:", error_15);
+                        throw error_15;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCurrentCpuMips = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_16;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        console.log("测试", cpuList[0].getName());
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getCpuMips(cpuList[0].getName()))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_16 = _a.sent();
+                        console.error("Error during getCurrentCpuMips:", error_16);
+                        throw error_16;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getGlobalVarValue = function (cpuName, varName, bytesNum, valueType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_17;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getGlobalVarValue(cpuName, varName, bytesNum, valueType))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_17 = _a.sent();
+                        console.error("Error during getGlobalVarValue:", error_17);
+                        throw error_17;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getGlobalVarValueDefault = function (varName, valueType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_18;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getGlobalVarValue(cpuList[0].getName(), varName, "4", valueType))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_18 = _a.sent();
+                        console.error("Error during getGlobalVarValueDefault:", error_18);
+                        throw error_18;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setGlobalVarValue = function (cpuName, varName, bytesNum, valueType, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_19;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().setGlobalVarValue(cpuName, varName, bytesNum, valueType, value))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_19 = _a.sent();
+                        console.error("Error during setGlobalVarValue:", error_19);
+                        throw error_19;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setGlobalVarValueDefault = function (varName, valueType, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_20;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().setGlobalVarValue(cpuList[0].getName(), varName, "4", valueType, value))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_20 = _a.sent();
+                        console.error("Error during setGlobalVarValueDefault:", error_20);
+                        throw error_20;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getMemoryValue = function (cpuName, baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    return [2 /*return*/, this.getAddressingSpace(cpuName, baseAddr, length)];
+                }
+                catch (error) {
+                    console.error("Error during getMemoryValue:", error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SkyEyeClient.prototype.getAddressingSpace = function (cpuName, baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_21;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getMemoryValue(cpuName, baseAddr, length))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_21 = _a.sent();
+                        console.error("Error during getAddressingSpace:", error_21);
+                        throw error_21;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getMemoryValueDefault = function (baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    return [2 /*return*/, this.getAddressingSpaceDefault(baseAddr, length)];
+                }
+                catch (error) {
+                    console.error("Error during getMemoryValue:", error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SkyEyeClient.prototype.getAddressingSpaceDefault = function (baseAddr, length) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_22;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getMemoryValue(cpuList[0].getName(), baseAddr, length))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_22 = _a.sent();
+                        console.error("Error during getAddressingSpaceDefault:", error_22);
+                        throw error_22;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCpuRegisters = function (cpuName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, it, error_23;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetCpuRegisterInfoResponse_1.GetCpuRegisterInfoResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getcpuRegisterInfo(cpuName))];
+                    case 2:
+                        call = _a.sent();
+                        if (call != null) {
+                            response.isSuccess = true;
+                            it = call.result;
+                            it.forEach(function (item) {
+                                var register = new Register_1.Register(null);
+                                register.name = item.name;
+                                register.bits = item.size;
+                                register.description = item.desc;
+                                register.value = item.value;
+                                register.offset = item.offset;
+                                response.registers.push(register);
+                                response.registers.sort(function (r1, r2) {
+                                    if (r1.offset == null) {
+                                        return 1;
+                                    }
+                                    if (r2.offset == null) {
+                                        return -1;
+                                    }
+                                    if (r1.offset === r2.offset) {
+                                        return 0;
+                                    }
+                                    var numOffset1 = parseInt(r1.offset);
+                                    var numOffset2 = parseInt(r2.offset);
+                                    var result = 0;
+                                    if (!isNaN(numOffset1) && !isNaN(numOffset2)) {
+                                        result = numOffset1 - numOffset2;
+                                        console.log("Result:", result);
+                                    }
+                                    else {
+                                        console.log("Invalid offset values.");
+                                    }
+                                    return result > 0 ? 1 : -1;
+                                    // return r1.offset! - r2.offset! > 0 ? 1 : -1;
+                                });
+                            });
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_23 = _a.sent();
+                        console.error("Error during getCpuRegistersDefault:", error_23);
+                        throw error_23;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCpuRegistersDefault = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList, error_24;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList();
+                        if (!(cpuList != null && cpuList.length > 0)) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.getCpuRegisters(cpuList[0].getName())];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_24 = _a.sent();
+                        console.error("Error during getCpuRegistersDefault:", error_24);
+                        throw error_24;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        console.error("无法获取cpu，请确认cpu是否存在:");
+                        throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setCpuRegisterValueDefault = function (register, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_25;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.setCpuRegisterValue(register.getParent().getParent().getName(), register.getParent().getName(), register.getName(), value)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_25 = _a.sent();
+                        console.error("Error during getCpuRegistersDefault:", error_25);
+                        throw error_25;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setCpuRegisterValue = function (boardName, cpuName, registerName, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var deviceTree, board, deviceMap, cpu, error_26;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getDeviceTree()];
+                    case 1:
+                        deviceTree = _a.sent();
+                        if (!deviceTree.boardMap.has(boardName)) {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("未能找到该板卡");
+                        }
+                        board = boardMap.get(boardName);
+                        deviceMap = board.getDeveceMap();
+                        if (!deviceMap.has(cpuName) || !(deviceMap.get(cpuName) instanceof Cpu_1.Cpu)) {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("未能找到该设备");
+                        }
+                        cpu = deviceMap.get(cpuName);
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().setRegisterValue(cpu.getParent().getName(), cpuName, registerName, value))];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_26 = _a.sent();
+                        console.error("Error during getAddressingSpace:", error_26);
+                        throw error_26;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getDeviceTree = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, response, call, boardMap_1, error_27;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCurrentRunningState()];
+                    case 1:
+                        state = (_a.sent()).getState();
+                        if (GetRunningStateResponse_1.StateState.UNLOADED === state || GetRunningStateResponse_1.StateState.QUITED === state) {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("当前SkyEye未加载配置，需要加载配置可以获取设备树信息，请检查当前配置");
+                        }
+                        response = new GetDeviceTreeResponse_1.GetDeviceTreeResponse();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getDeviceTree())];
+                    case 3:
+                        call = _a.sent();
+                        console.log("call:", call);
+                        if (call.result != null) {
+                            boardMap_1 = ParseBoardUtils_1.ParseBoardUtils.parseBoard(call.result);
+                            response.boardMap = boardMap_1;
+                            response.isSuccess = true;
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_27 = _a.sent();
+                        console.error("Error during getAddressingSpace:", error_27);
+                        throw error_27;
+                    case 5: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getCurrentRunningState = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, error_28;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetRunningStateResponse_1.GetRunningStateResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getRunningStatus())
+                            // { result: 2, error: null, name: 'SE_get_running_status' }
+                        ];
+                    case 2:
+                        call = _a.sent();
+                        // { result: 2, error: null, name: 'SE_get_running_status' }
+                        if (call != null) {
+                            response.isSuccess = true;
+                            switch (call.result) {
+                                case 1:
+                                    response.setState(GetRunningStateResponse_1.StateState.UNLOADED);
+                                    break;
+                                case 2:
+                                    response.setState(GetRunningStateResponse_1.StateState.RUNNING);
+                                    break;
+                                case 3:
+                                    response.setState(GetRunningStateResponse_1.StateState.STOPPED);
+                                    break;
+                            }
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_28 = _a.sent();
+                        console.error("Error during getCurrentRunningState:", error_28);
+                        throw error_28;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getAllDeviceInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, boardMap_2, error_29;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetAllDeviceInfoResponse_1.GetAllDeviceInfoResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getAllDeviceInfo())];
+                    case 2:
+                        call = _a.sent();
+                        if (call != null) {
+                            response.isSuccess = true;
+                            boardMap_2 = ParseBoardUtils_1.ParseBoardUtils.parseBoard(call.result);
+                            response.boardMap = boardMap_2;
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_29 = _a.sent();
+                        console.error("Error during getAllDeviceInfo:", error_29);
+                        throw error_29;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getRamAddrInfo = function (machName, addr) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, error_30;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetRamAddrInfoResponse_1.GetRamAddrInfoResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getRamAddrInfo(machName, addr))];
+                    case 2:
+                        call = _a.sent();
+                        if (call.result != null) {
+                            response.isSuccess = true;
+                            response.bits = call.result.bits;
+                            response.value = call.result.value;
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_30 = _a.sent();
+                        console.error("Error during getRamAddrInfo:", error_30);
+                        throw error_30;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setRamFaultInjectDefault = function (device, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_31;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.setRamFaultInject(device.getParent().getName(), device.getName(), addr, bit, mode)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_31 = _a.sent();
+                        throw error_31;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setRamFaultInject = function (boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_32;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().setFaultInject(boardName, deviceName, String(addr), String(bit), mode))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_32 = _a.sent();
+                        throw error_32;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setRegisterFaultInjectDefault = function (register, bit, mode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_33;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.setRegisterFaultInject(register.getParent().getParent().getName(), register.getParent().getName(), register.baseAddr, bit, mode)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_33 = _a.sent();
+                        throw error_33;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.setRegisterFaultInject = function (boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_34;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().setFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_34 = _a.sent();
+                        throw error_34;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.deleteFaultInjectDefault = function (faultInjectItem) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_35;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.deleteFaultInject(faultInjectItem.boardName, faultInjectItem.deviceName, faultInjectItem.addr, String(faultInjectItem.bit), faultInjectItem.type)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_35 = _a.sent();
+                        throw error_35;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.deleteFaultInject = function (boardName, deviceName, addr, bit, mode) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_36;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().deleteFaultInject(boardName, deviceName, "0x" + String(addr), String(bit), mode))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_36 = _a.sent();
+                        throw error_36;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getFaultInjectList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, items_1, error_37;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetFaultInjectListResponse_1.GetFaultInjectListResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getFaultInjectList())];
+                    case 2:
+                        call = _a.sent();
+                        if (call.result != null) {
+                            response.isSuccess = true;
+                            items_1 = new Array();
+                            call.result.forEach(function (item) {
+                                var faultInjectItem = new FaultInjectItem_1.FaultInjectItem(null);
+                                if (item != null) {
+                                    faultInjectItem.deviceName = item.get(1);
+                                    faultInjectItem.registerName = item.get(2);
+                                    faultInjectItem.addr = item.get(3);
+                                    faultInjectItem.bit = item.get(4);
+                                    switch (String(item.get(5))) {
+                                        case "0":
+                                            faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_ZERO;
+                                            break;
+                                        case "1":
+                                            faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_ONE;
+                                            break;
+                                        case "2":
+                                            faultInjectItem.type = FaultInjectType_1.FaultInjectType.SET_REVE;
+                                            break;
+                                    }
+                                }
+                                items_1.push(faultInjectItem);
+                            });
+                            response.faultInjectItems = items_1;
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_37 = _a.sent();
+                        throw error_37;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getDisassembleInfo = function (cpuName, startAddr, nums) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, call, instructionItems_1, error_38;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new GetDisassembleInfoResponse_1.GetDisassembleInfoResponse();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().getDisassembleInfo(cpuName, startAddr, nums))];
+                    case 2:
+                        call = _a.sent();
+                        if (call.result != null) {
+                            response.isSuccess = true;
+                            instructionItems_1 = new Array();
+                            call.result.forEach(function (item) {
+                                var instructionItem = new InstructionItem_1.InstructionItem();
+                                instructionItem.addr = item.get(0);
+                                instructionItem.func = item.get(1);
+                                instructionItem.content = item.get(2);
+                                instructionItems_1.push(instructionItem);
+                            });
+                            response.instructions = instructionItems_1;
+                        }
+                        else {
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException(String(call.error));
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_38 = _a.sent();
+                        throw error_38;
+                    case 4: return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.getDisassembleInfoDefault = function (startAddr, nums) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList;
+                        if (cpuList != null && cpuList.length > 0) {
+                            return [2 /*return*/, this.getDisassembleInfo(cpuList[0].name, startAddr, nums)];
+                        }
+                        else {
+                            console.error("无法获取cpu，请确认cpu是否存在:");
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.SingleStep = function (cpuName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_39;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.call(RequestFactory_1.RequestFactory.getInstance().singleStep(cpuName))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        error_39 = _a.sent();
+                        throw error_39;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.SingleStepDefault = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cpuList;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCpuList()];
+                    case 1:
+                        cpuList = (_a.sent()).getCpuList;
+                        if (cpuList != null && cpuList.length > 0) {
+                            return [2 /*return*/, this.SingleStep(cpuList[0].name)];
+                        }
+                        else {
+                            console.error("无法获取cpu，请确认cpu是否存在:");
+                            throw new SkyEyeSDKException_1.SkyEyeSDKException("无法获取cpu，请确认cpu是否存在:");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SkyEyeClient.prototype.close = function () {
+        _super.prototype.close.call(this);
+        console.log('gRPC客户端已断开');
+        return true;
+    };
+    SkyEyeClient.prototype.getHost = function () {
+        return this.host;
+    };
+    SkyEyeClient.prototype.getPort = function () {
+        return this.port;
+    };
+    SkyEyeClient.prototype.initSkyEyeAndRun = function (pathSkyEye, fileName, port, skyeyeDir) {
+        var _this = this;
+        console.log('runExample');
+        cp.exec(skyeyeDir + " -q " + port + "\n", function (err, stdout, stderr) {
+            console.log('stdout: ' + stdout);
+            console.log('stderr: ' + stderr);
+        });
+        setTimeout(function () {
+            client = new skyeye_rpc_grpc_pb_1.JSONTransmissionClient('127.0.0.1:' + port, grpc.credentials.createInsecure());
+            console.log('client:' + client);
+            var Jr = new skyeye_rpc_pb_1.JSONRequest();
+            Jr.setRequest("{\"request\": {\"name\": \"chdir\", \"args\": {\"path\":\"" + pathSkyEye + "\"}}}");
+            client.callSkyEye(Jr, function (error, response) {
+                console.log("chdir res:" + response + error);
+                Jr.setRequest("{\"request\": {\"name\": \"run_script\", \"args\": {\"filename\":\"" + fileName + "\"}}}");
+                client.callSkyEye(Jr, function (error, response) {
+                    console.log("run_script res:" + response + error);
+                    _this.runCommand();
+                    return "1";
+                });
+            });
+        }, 2000);
+    };
+    return SkyEyeClient;
+}(skyeye_rpc_grpc_pb_1.JSONTransmissionClient));
+exports.SkyEyeClient = SkyEyeClient;