23b8e59ab9
* Panic guard for DAP request handling * Use GetSeq * Re-vendor new version of go-dap * Remove comment * Update error message * Reuse er.Message in Format
220 lines
11 KiB
Go
220 lines
11 KiB
Go
// Copyright 2020 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// This file contains utilities for decoding JSON-encoded bytes into DAP message.
|
|
|
|
package dap
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
// DecodeProtocolMessageFieldError describes which JSON attribute
|
|
// has an unsupported value that the decoding cannot handle.
|
|
type DecodeProtocolMessageFieldError struct {
|
|
SubType string
|
|
FieldName string
|
|
FieldValue string
|
|
}
|
|
|
|
func (e *DecodeProtocolMessageFieldError) Error() string {
|
|
return fmt.Sprintf("%s %s '%s' is not supported", e.SubType, e.FieldName, e.FieldValue)
|
|
}
|
|
|
|
// DecodeProtocolMessage parses the JSON-encoded data and returns the result of
|
|
// the appropriate type within the ProtocolMessage hierarchy. If message type,
|
|
// command, etc cannot be cast, returns DecodeProtocolMessageFieldError.
|
|
// See also godoc for json.Unmarshal, which is used for underlying decoding.
|
|
func DecodeProtocolMessage(data []byte) (Message, error) {
|
|
var protomsg ProtocolMessage
|
|
if err := json.Unmarshal(data, &protomsg); err != nil {
|
|
return nil, err
|
|
}
|
|
switch protomsg.Type {
|
|
case "request":
|
|
return decodeRequest(data)
|
|
case "response":
|
|
return decodeResponse(data)
|
|
case "event":
|
|
return decodeEvent(data)
|
|
default:
|
|
return nil, &DecodeProtocolMessageFieldError{"ProtocolMessage", "type", protomsg.Type}
|
|
}
|
|
}
|
|
|
|
type messageCtor func() Message
|
|
|
|
// decodeRequest determines what request type in the ProtocolMessage hierarchy
|
|
// data corresponds to and uses json.Unmarshal to populate the corresponding
|
|
// struct to be returned.
|
|
func decodeRequest(data []byte) (Message, error) {
|
|
var r Request
|
|
if err := json.Unmarshal(data, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
if ctor, ok := requestCtor[r.Command]; ok {
|
|
requestPtr := ctor()
|
|
err := json.Unmarshal(data, requestPtr)
|
|
return requestPtr, err
|
|
}
|
|
return nil, &DecodeProtocolMessageFieldError{"Request", "command", r.Command}
|
|
}
|
|
|
|
// Mapping of request commands and corresponding struct constructors that
|
|
// can be passed to json.Unmarshal.
|
|
var requestCtor = map[string]messageCtor{
|
|
"cancel": func() Message { return &CancelRequest{} },
|
|
"runInTerminal": func() Message { return &RunInTerminalRequest{} },
|
|
"initialize": func() Message { return &InitializeRequest{} },
|
|
"configurationDone": func() Message { return &ConfigurationDoneRequest{} },
|
|
"launch": func() Message { return &LaunchRequest{} },
|
|
"attach": func() Message { return &AttachRequest{} },
|
|
"restart": func() Message { return &RestartRequest{} },
|
|
"disconnect": func() Message { return &DisconnectRequest{} },
|
|
"terminate": func() Message { return &TerminateRequest{} },
|
|
"breakpointLocations": func() Message { return &BreakpointLocationsRequest{} },
|
|
"setBreakpoints": func() Message { return &SetBreakpointsRequest{} },
|
|
"setFunctionBreakpoints": func() Message { return &SetFunctionBreakpointsRequest{} },
|
|
"setExceptionBreakpoints": func() Message { return &SetExceptionBreakpointsRequest{} },
|
|
"dataBreakpointInfo": func() Message { return &DataBreakpointInfoRequest{} },
|
|
"setDataBreakpoints": func() Message { return &SetDataBreakpointsRequest{} },
|
|
"continue": func() Message { return &ContinueRequest{} },
|
|
"next": func() Message { return &NextRequest{} },
|
|
"stepIn": func() Message { return &StepInRequest{} },
|
|
"stepOut": func() Message { return &StepOutRequest{} },
|
|
"stepBack": func() Message { return &StepBackRequest{} },
|
|
"reverseContinue": func() Message { return &ReverseContinueRequest{} },
|
|
"restartFrame": func() Message { return &RestartFrameRequest{} },
|
|
"goto": func() Message { return &GotoRequest{} },
|
|
"pause": func() Message { return &PauseRequest{} },
|
|
"stackTrace": func() Message { return &StackTraceRequest{} },
|
|
"scopes": func() Message { return &ScopesRequest{} },
|
|
"variables": func() Message { return &VariablesRequest{} },
|
|
"setVariable": func() Message { return &SetVariableRequest{} },
|
|
"source": func() Message { return &SourceRequest{} },
|
|
"threads": func() Message { return &ThreadsRequest{} },
|
|
"terminateThreads": func() Message { return &TerminateThreadsRequest{} },
|
|
"modules": func() Message { return &ModulesRequest{} },
|
|
"loadedSources": func() Message { return &LoadedSourcesRequest{} },
|
|
"evaluate": func() Message { return &EvaluateRequest{} },
|
|
"setExpression": func() Message { return &SetExpressionRequest{} },
|
|
"stepInTargets": func() Message { return &StepInTargetsRequest{} },
|
|
"gotoTargets": func() Message { return &GotoTargetsRequest{} },
|
|
"completions": func() Message { return &CompletionsRequest{} },
|
|
"exceptionInfo": func() Message { return &ExceptionInfoRequest{} },
|
|
"readMemory": func() Message { return &ReadMemoryRequest{} },
|
|
"disassemble": func() Message { return &DisassembleRequest{} },
|
|
}
|
|
|
|
// decodeResponse determines what response type in the ProtocolMessage hierarchy
|
|
// data corresponds to and uses json.Unmarshal to populate the corresponding
|
|
// struct to be returned.
|
|
func decodeResponse(data []byte) (Message, error) {
|
|
var r Response
|
|
if err := json.Unmarshal(data, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
if !r.Success {
|
|
var er ErrorResponse
|
|
err := json.Unmarshal(data, &er)
|
|
return &er, err
|
|
}
|
|
if ctor, ok := responseCtor[r.Command]; ok {
|
|
responsePtr := ctor()
|
|
err := json.Unmarshal(data, responsePtr)
|
|
return responsePtr, err
|
|
}
|
|
return nil, &DecodeProtocolMessageFieldError{"Response", "command", r.Command}
|
|
}
|
|
|
|
// Mapping of response commands and corresponding struct constructors that
|
|
// can be passed to json.Unmarshal.
|
|
var responseCtor = map[string]messageCtor{
|
|
"cancel": func() Message { return &CancelResponse{} },
|
|
"runInTerminal": func() Message { return &RunInTerminalResponse{} },
|
|
"initialize": func() Message { return &InitializeResponse{} },
|
|
"configurationDone": func() Message { return &ConfigurationDoneResponse{} },
|
|
"launch": func() Message { return &LaunchResponse{} },
|
|
"attach": func() Message { return &AttachResponse{} },
|
|
"restart": func() Message { return &RestartResponse{} },
|
|
"disconnect": func() Message { return &DisconnectResponse{} },
|
|
"terminate": func() Message { return &TerminateResponse{} },
|
|
"breakpointLocations": func() Message { return &BreakpointLocationsResponse{} },
|
|
"setBreakpoints": func() Message { return &SetBreakpointsResponse{} },
|
|
"setFunctionBreakpoints": func() Message { return &SetFunctionBreakpointsResponse{} },
|
|
"setExceptionBreakpoints": func() Message { return &SetExceptionBreakpointsResponse{} },
|
|
"dataBreakpointInfo": func() Message { return &DataBreakpointInfoResponse{} },
|
|
"setDataBreakpoints": func() Message { return &SetDataBreakpointsResponse{} },
|
|
"continue": func() Message { return &ContinueResponse{} },
|
|
"next": func() Message { return &NextResponse{} },
|
|
"stepIn": func() Message { return &StepInResponse{} },
|
|
"stepOut": func() Message { return &StepOutResponse{} },
|
|
"stepBack": func() Message { return &StepBackResponse{} },
|
|
"reverseContinue": func() Message { return &ReverseContinueResponse{} },
|
|
"restartFrame": func() Message { return &RestartFrameResponse{} },
|
|
"goto": func() Message { return &GotoResponse{} },
|
|
"pause": func() Message { return &PauseResponse{} },
|
|
"stackTrace": func() Message { return &StackTraceResponse{} },
|
|
"scopes": func() Message { return &ScopesResponse{} },
|
|
"variables": func() Message { return &VariablesResponse{} },
|
|
"setVariable": func() Message { return &SetVariableResponse{} },
|
|
"source": func() Message { return &SourceResponse{} },
|
|
"threads": func() Message { return &ThreadsResponse{} },
|
|
"terminateThreads": func() Message { return &TerminateThreadsResponse{} },
|
|
"modules": func() Message { return &ModulesResponse{} },
|
|
"loadedSources": func() Message { return &LoadedSourcesResponse{} },
|
|
"evaluate": func() Message { return &EvaluateResponse{} },
|
|
"setExpression": func() Message { return &SetExpressionResponse{} },
|
|
"stepInTargets": func() Message { return &StepInTargetsResponse{} },
|
|
"gotoTargets": func() Message { return &GotoTargetsResponse{} },
|
|
"completions": func() Message { return &CompletionsResponse{} },
|
|
"exceptionInfo": func() Message { return &ExceptionInfoResponse{} },
|
|
"readMemory": func() Message { return &ReadMemoryResponse{} },
|
|
"disassemble": func() Message { return &DisassembleResponse{} },
|
|
}
|
|
|
|
// decodeEvent determines what event type in the ProtocolMessage hierarchy
|
|
// data corresponds to and uses json.Unmarshal to populate the corresponding
|
|
// struct to be returned.
|
|
func decodeEvent(data []byte) (Message, error) {
|
|
var e Event
|
|
if err := json.Unmarshal(data, &e); err != nil {
|
|
return nil, err
|
|
}
|
|
if ctor, ok := eventCtor[e.Event]; ok {
|
|
eventPtr := ctor()
|
|
err := json.Unmarshal(data, eventPtr)
|
|
return eventPtr, err
|
|
}
|
|
return nil, &DecodeProtocolMessageFieldError{"Event", "event", e.Event}
|
|
}
|
|
|
|
// Mapping of event ids and corresponding struct constructors that
|
|
// can be passed to json.Unmarshal.
|
|
var eventCtor = map[string]messageCtor{
|
|
"initialized": func() Message { return &InitializedEvent{} },
|
|
"stopped": func() Message { return &StoppedEvent{} },
|
|
"continued": func() Message { return &ContinuedEvent{} },
|
|
"exited": func() Message { return &ExitedEvent{} },
|
|
"terminated": func() Message { return &TerminatedEvent{} },
|
|
"thread": func() Message { return &ThreadEvent{} },
|
|
"output": func() Message { return &OutputEvent{} },
|
|
"breakpoint": func() Message { return &BreakpointEvent{} },
|
|
"module": func() Message { return &ModuleEvent{} },
|
|
"loadedSource": func() Message { return &LoadedSourceEvent{} },
|
|
"process": func() Message { return &ProcessEvent{} },
|
|
"capabilities": func() Message { return &CapabilitiesEvent{} },
|
|
}
|