DebugProgramControl.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  DebugProgramControl.qm Copyright 2013 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// minimum required Qore version
 
// child program won't inherit parent program options (including %allow-debugger)
 
 
namespace DebugProgramControl {
class DebugProgramControl : public DebugProgram, public AbstractDebugControl {
 
public:
protected:
            hash ctxThread;
            hash ctxConnection;
            Qore::Thread::RWLock rwlThread();
            Qore::Thread::RWLock rwlConnection();
            string serverName;
            string sourceSearchPath = "";
 
            const frameOffset = 2;
 
public:
            const DEFAULT_LINES_BEFORE = 3;
            const DEFAULT_LINES_AFTER = 3;
 
        constructor(string serverName) ;
 
 
        destructor();
 
 
        shutdown();
 
 
         registerConnection(hash cx);
 
         connectionRegistered(hash cx);
 
         unregisterConnection(hash cx);
 
         unregisterAllConnections();
 
 
         list getConnectionIds();
 
        abstract  sendDataImpl(hash cx, auto data);        
        abstract  broadcastDataImpl(auto data);
protected:
         broadcastBreakpoint(hash cx, Breakpoint b, string change);
public:
 
 
         Program createProgram(string fileName, *hash opts, list args, *string script);
 
protected:
         *int runAndDetach(Program pgm);
public:
 
 
         *hash processCommand(hash cx, hash receiveData);
 
protected:
         auto resolveValue(string name, *string val, hash strings, auto defVal);
public:
 
 
protected:
         string encodeValue(string name, auto val, hash strings);
public:
 
 
protected:
         int resolveStatement(ProgramControl pgm, *hash value);
public:
 
 
protected:
         hash getProgramInfo(ProgramControl p, bool listFiles = False, *list threads);
public:
 
 
protected:
         hash getBreakpointInfo(Breakpoint b, bool listStatements = True);
public:
 
 
        // stackInfo keys: file, [source], [offset], line
protected:
         *hash getSourceCodeFromFileOrLabel(ProgramControl pgm, hash stackInfo, int linesBefore, int linesAfter);
public:
 
 
protected:
         *hash getSourceCode(ProgramControl pgmb, string type, hash rd);
public:
 
 
protected:
         bool isSupportedSourceCodeForLabel();
public:
 
 
protected:
         hash<auto> getSourceCodeForLabel(string name);
public:
 
protected:
         hash<auto> getSourceCodeFromFile(string name);
public:
 
 
protected:
         *hash serializeLocal(string name, hash val);
public:
 
 
protected:
         *hash serializeLocals(*hash vals);
public:
 
 
protected:
         list adjustStack(list stack, *hash ctx);
public:
 
 
protected:
         *hash handleInterrupt(string func, ProgramControl pgm, reference runState, reference runToStatementId, *int statementId, *string refName, *reference refValue, *int breakpointId, *hash except);
public:
 
 
        onAttach(ProgramControl pgm, reference rs, reference runToStatementId);
 
 
        onDetach(ProgramControl pgm, reference rs, reference runToStatementId);
 
 
        onStep(ProgramControl pgm, int blockStatementId, *int statementId, *int breakpointId, reference flow, reference rs, reference runToStatementId);
 
 
        // backward compatability only when executed with <=0.8.13.2
        onStep(ProgramControl pgm, int blockStatementId, *int statementId, reference flow, reference rs, reference runToStatementId);
 
 
        onFunctionEnter(ProgramControl pgm, int statementId, reference rs, reference runToStatementId);
 
 
        onFunctionExit(ProgramControl pgm, int statementId, reference result, reference rs, reference runToStatementId);
 
 
        onException(ProgramControl pgm, int statementId, hash ex, reference dismiss, reference rs, reference runToStatementId);
 
 
        onExit(ProgramControl pgm, int statementId, reference result, reference rs, reference runToStatementId);
 
    };
};