Method evaluateRequest

src/gdb.ts:3105–3264

(r: DebugProtocol.EvaluateResponse, a: DebugProtocol.EvaluateArguments)

    private evaluateQ = new RequestQueue<DebugProtocol.EvaluateResponse, DebugProtocol.EvaluateArguments>();
    protected evaluateRequest(r: DebugProtocol.EvaluateResponse, a: DebugProtocol.EvaluateArguments): Promise<void> {
        a.context = a.context || 'hover';       // Not sure who is calling with an undefined context
        if (a.context !== 'repl') {
            if (this.isBusy()) {
                this.busyError(r, a);
                return Promise.resolve();
            }
        }

        const doit = (response: DebugProtocol.EvaluateResponse, args: DebugProtocol.EvaluateArguments) => {
            return new Promise<void>(async (resolve) => {
                if (this.isBusy() && (a.context !== 'repl')) {
                    this.busyError(response, args);
                    resolve();
                    return;
                }
                const createVariable = (arg, options?) => {
                    if (options) {
                        return this.variableHandles.create(new ExtendedVariable(arg, options));
                    }
                    else {
                        return this.variableHandles.create(arg);
                    }
                };

                const findOrCreateVariable = (varObj: VariableObject): number => {
                    let id: number;
                    if (this.variableHandlesReverse.hasOwnProperty(varObj.name)) {
                        id = this.variableHandlesReverse[varObj.name];
                    }
                    else {
                        id = createVariable(varObj);
                        this.variableHandlesReverse[varObj.name] = id;
                    }
                    return varObj.isCompound() ? id : 0;
                };

                // Spec says if 'frameId' is specified, evaluate in the scope specified or in the global scope. Well,
                // we don't have a way to specify global scope ... use floating variable.
                let threadId = this.stoppedThreadId || 1;
                let frameId = 0;
                if (args.frameId !== undefined) {     // Should always be valid
                    [threadId, frameId] = decodeReference(args.frameId);
                }

                if (args.context !== 'repl') {
                    try {
                        const exp = args.expression;
                        const hasher = crypto.createHash('sha256');
                        hasher.update(exp);
                        if (args.frameId !== undefined) {
                            hasher.update(args.frameId.toString(16));
                        }
                        const exprName = hasher.digest('hex');
                        const varObjName = `${args.context}_${exprName}`;
                        let varObj: VariableObject;
                        let outOfScope = false;
                        try {