Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Este tópico descreve como usar o script C++ do Debugger Data Model C++ Debugger Data Model para oferecer suporte à automação com o mecanismo do depurador usando scripts.
gerenciamento de scripts no modelo de dados do depurador
Além do papel do Data Model Manager como autoridade central na criação e extensibilidade de objetos, ele também é responsável pelo gerenciamento de um conceito abstrato de scripts. Da perspetiva da parte do Gerenciador de Scripts do Gerenciador de Modelo de Dados, um script é algo que pode ser carregado, descarregado e potencialmente depurado dinamicamente por um provedor para estender ou fornecer novas funcionalidades ao modelo de dados.
Um provedor de script é um componente que faz a ponte entre uma linguagem (por exemplo: NatVis, JavaScript, etc...) para o modelo de dados. Ele registra uma ou mais extensões de arquivo (por exemplo: ". NatVis", ".js") que são manipulados pelo provedor permitindo que um cliente depurador ou uma interface de usuário permita o carregamento de arquivos de script com essa extensão específica por delegação ao provedor.
O Gerenciador de Scripts Principais: IDataModelScriptManager
A interface principal do gerenciador de scripts é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptManager, IUnknown)
{
STDMETHOD(GetDefaultNameBinder)(_COM_Outptr_ IDataModelNameBinder **ppNameBinder) PURE;
STDMETHOD(RegisterScriptProvider)(_In_ IDataModelScriptProvider *provider) PURE;
STDMETHOD(UnregisterScriptProvider)(_In_ IDataModelScriptProvider *provider) PURE;
STDMETHOD(FindProviderForScriptType)(_In_ PCWSTR scriptType, _COM_Outptr_ IDataModelScriptProvider **provider) PURE;
STDMETHOD(FindProviderForScriptExtension)(_In_ PCWSTR scriptExtension, _COM_Outptr_ IDataModelScriptProvider **provider) PURE;
STDMETHOD(EnumerateScriptProviders)(_COM_Outptr_ IDataModelScriptProviderEnumerator **enumerator) PURE;
}
O método GetDefaultNameBinder retorna o fichário de nome de script padrão do modelo de dados. Um fichário de nome é um componente que resolve um nome dentro do contexto de um objeto. Por exemplo, dada a expressão "foo.bar", um fichário de nome é chamado para resolver a barra de nomes no contexto do objeto foo. O fichário retornado aqui segue um conjunto de regras padrão para o modelo de dados. Os provedores de script podem usar esse fichário para fornecer consistência na resolução de nomes entre provedores.
O método RegisterScriptProvider informa ao modelo de dados que existe um novo provedor de script capaz de fazer a ponte entre uma nova linguagem e o modelo de dados. Quando esse método é chamado, o gerenciador de scripts imediatamente chamará de volta o provedor de script fornecido e perguntará sobre as propriedades dos scripts que ele gerencia. Se já houver um provedor registrado sob o nome ou extensão de arquivo que o provedor de script fornecido indica, esse método falhará. Somente um único provedor de script pode ser registrado como o manipulador para um nome específico ou extensão de arquivo.
O método UnregisterScriptProvider desfaz uma chamada para o método RegisterScriptProvider. O nome e a extensão de arquivo fornecidos pelo provedor de script inpassado não serão mais associados a ele. É importante notar que pode haver um número significativo de referências COM pendentes para o provedor de script, mesmo após o cancelamento do registro. Esse método impede apenas o carregamento/criação de scripts do tipo que determinado provedor de scripts gerencia. Se um script carregado por esse provedor ainda estiver carregado ou tiver manipulado o modelo de objeto do depurador (ou modelo de dados), essas manipulações ainda poderão ter referências de volta ao script. Pode haver modelos de dados, métodos ou objetos que fazem referência direta a construções no script. Um provedor de scripts deve estar preparado para lidar com isso.
O método FindProviderForScriptType procura no gerenciador de scripts um provedor que tenha uma cadeia de caracteres de tipo de script, conforme indicado nesse método. Se não for possível encontrá-lo, este método falhará; caso contrário, esse provedor de script será retornado ao chamador.
O método EnumerateScriptProviders retornará um enumerador que enumerará cada provedor de script que foi registrado com o gerenciador de scripts por meio de uma chamada anterior para o método RegisterScriptProvider.
Enumeração do provedor de script: IDataModelScriptProviderEnumerator
O método EnumerateScriptProviders retornará um enumerador do seguinte formato:
DECLARE_INTERFACE_(IDataModelScriptProviderEnumerator, IUnknown)
{
STDMETHOD(Reset)() PURE;
STDMETHOD(GetNext)(_COM_Outptr_ IDataModelScriptProvider **provider) PURE;
}
O método Reset moverá o enumerador para a posição em que estava antes de retornar o primeiro elemento.
O método GetNext moverá o enumerador para frente um elemento e retornará o provedor de script que está nesse elemento. Quando o enumerador atingir o final da enumeração, E_BOUNDS será retornado. Chamar o método GetNext depois de receber esse erro continuará a retornar E_BOUNDS indefinidamente.
Depurador Data Model C++ Host Interfaces para Scripting
O papel do host no script
O host de depuração expõe uma série de interfaces de nível muito baixo para entender a natureza do sistema de tipo do(s) seu(s) alvo(s) de depuração, avaliar expressões na linguagem do(s) seu(s) alvo(s) de depuração, etc... Normalmente, ele não está preocupado com construções de nível superior, como scripts. Isso é deixado para o aplicativo depurador geral ou para extensões que fornecem esses recursos. Existe, no entanto, uma exceção. Qualquer host de depuração que queira participar da experiência geral de script proporcionada pelo modelo de dados precisa implementar algumas interfaces simples para fornecer contextos aos scripts. Na verdade, o host de depuração está no controle de onde deseja que o ambiente de script coloque funções e outras funcionalidades fornecidas pelo script dentro do namespace do modelo de dados. Estar envolvido neste processo permite ao anfitrião permitir (ou não) o uso de tais funções, por exemplo, no seu avaliador de expressão. As interfaces envolvidas da perspetiva do host aqui são:
| Interfaz | Descrição |
|---|---|
| IDebugHostScriptHost | A interface que indica a capacidade do host de depuração de participar do ambiente de script. Esta interface permite a criação de contextos que informam os mecanismos de script de onde colocar objetos. |
| IDataModelScriptHostContext | Uma interface de host que é usada pelo provedor de script como um contêiner para o conteúdo do script. Como o conteúdo de uma superfície de script diferente das manipulações que ele executa no modelo de objeto do aplicativo depurador depende do host de depuração específico. Essa interface permite que o provedor de scripts obtenha informações sobre onde colocar seu conteúdo. Consulte Data Model C++ Scripting Interfaces mais adiante neste tópico para obter mais informações. |
o host de script do host de depuração: IDebugHostScriptHost
A interface IDebugHostScriptHost é a interface usada por um provedor de script para obter um contexto do host de depuração para um script recém-criado. Esse contexto inclui um objeto (fornecido pelo host de depuração) onde o provedor de script pode colocar quaisquer pontes entre o modelo de dados e o ambiente de script. Essas pontes podem, por exemplo, ser métodos de modelo de dados que invocam funções de script. Isso permite que um chamador no lado do modelo de dados invoque métodos de script utilizando o método Call na interface IModelMethod.
A interface IDebugHostScriptHost é definida da seguinte forma.
DECLARE_INTERFACE_(IDebugHostScriptHost, IUnknown)
{
STDMETHOD(CreateContext)(_In_ IDataModelScript* script, _COM_Outptr_ IDataModelScriptHostContext** scriptContext) PURE;
}
O método CreateContext é chamado por um provedor de script para criar um novo contexto no qual colocar o conteúdo do script. Esse contexto é representado pela interface IDataModelScriptHostContext descrita em detalhes na página Data Model C++ Scripting Interfaces.
Interfaces de script C++ do modelo de dados do depurador
Scripts e Interfaces de Script
A arquitetura geral do modelo de dados permite que um terceiro defina uma ponte entre alguma linguagem e o modelo de objeto do modelo de dados. Normalmente, a linguagem que está sendo conectada é uma linguagem de script, uma vez que o ambiente do modelo de dados é muito dinâmico. Um componente que define e implementa essa ponte entre uma linguagem e o modelo de objeto do modelo de dados é chamado de provedor de script. Quando inicializado, um provedor de script se registra com a parte do gerenciador de scripts do gerenciador de modelo de dados e qualquer interface que gerencie a extensibilidade permitirá subsequentemente a edição, carregamento, descarregamento e, potencialmente, depuração de scripts escritos na linguagem gerenciada pelo provedor de scripts.
Observe que as Ferramentas de Depuração para Windows atualmente definem dois provedores de script.
- O provedor NatVis. Este provedor é incorporado dentro de DbgEng.dll e pontes entre NatVis XML e modelos de dados, permitindo a visualização de tipos de dados nativos/de idioma.
- O provedor de JavaScript. Este provedor está contido em uma extensão de depurador herdada: JsProvider.dll. Ele faz a ponte entre scripts escritos na linguagem JavaScript e o modelo de dados, permitindo formas arbitrárias de controle e extensibilidade do depurador.
Novos provedores podem ser escritos que fazem a ponte entre outras linguagens (por exemplo: Python, etc...) para o modelo de dados. Tal seria atualmente encapsulado em extensões de depurador herdadas para fins de carregamento. O próprio provedor de scripts deve minimizar a dependência com interfaces de mecanismo herdadas e só deve utilizar as APIs do modelo de dados sempre que possível. Isso permitirá que o provedor seja feito portátil para outros ambientes com uma facilidade significativamente maior.
Há duas classes de interfaces relacionadas a provedores de script. A primeira classe de interfaces é para o gerenciamento geral de provedores de script e os scripts que eles gerenciam. A segunda classe de interfaces é para suporte de depuração de script. Embora o suporte para o primeiro conjunto seja obrigatório, o suporte para o segundo é opcional e pode não fazer sentido para todos os provedores.
As interfaces gerais de gestão são:
| Interfaz | Descrição |
|---|---|
| IDataModelScriptProvider | A interface principal que um provedor de script deve implementar. Esta é a interface que é registrada com a parte do gerenciador de scripts do gerenciador de modelo de dados, a fim de anunciar o suporte do provedor de um determinado tipo de script e registrar em relação a uma extensão de arquivo específica |
| IDataModelScript | Uma abstração de um script específico que está sendo gerenciado pelo provedor. Cada script que está sendo carregado ou sendo editado tem uma instância IDataModelScript separada |
| IDataModelScriptClient | Uma interface de cliente que é usada pelo provedor de script para comunicar informações a uma interface do usuário. Os provedores de script não implementam essa interface. O aplicativo que hospeda o modelo de dados que deseja fazer uso de provedores de script faz. Um provedor de script chamará métodos do cliente de script para relatar status, erros, etc... |
| IDataModelScriptHostContext | Uma interface de host que é usada pelo provedor de script como um contêiner para o conteúdo do script. Como o conteúdo de uma superfície de script diferente das manipulações que ele executa no modelo de objeto do aplicativo depurador depende do host de depuração específico. Essa interface permite que o provedor de scripts obtenha informações sobre onde colocar seu conteúdo. |
| IDataModelScriptTemplate | Os provedores de scripts podem fornecer um ou mais modelos que servem como pontos de partida para os usuários criarem scripts. Um aplicativo depurador que fornece um editor embutido pode pré-preencher novos scripts com conteúdo de modelo, conforme anunciado pelo provedor através desta interface. |
| IDataModelScriptTemplateEnumerator | Uma interface de enumerador que o provedor de script implementa para anunciar todos os vários modelos suportados. |
| IDataModelNameBinder | Um fichário de nome -- um objeto que pode associar um nome em um contexto a um valor. Para uma determinada expressão como "foo.bar", um fichário de nome é capaz de vincular o nome "barra" no contexto do objeto "foo" e produzir um valor ou referência a ele. Os fichários de nomes normalmente não são implementados por um provedor de script; em vez disso, o fichário padrão pode ser adquirido do modelo de dados e usado pelo provedor de script |
As interfaces de depuração são:
| Interfaz | Descrição |
|---|---|
| IDataModelScriptDebug | A interface principal que um provedor de script deve fornecer para tornar um script depurável. A classe de implementação da interface IDataModelScript deve QueryInterface for IDataModelScriptDebug se o script for depurável. |
| IDataModelScriptDebugClient | A interface do usuário que deseja fornecer a capacidade de depuração de script implementa a interface IDataModelScriptDebugClient. O provedor de script utiliza essa interface para passar informações de depuração para frente e para trás (por exemplo: eventos que ocorrem, pontos de interrupção, etc...) |
| IDataModelScriptDebugStack | O provedor de script implementa essa interface para expor a noção de uma pilha de chamadas para o depurador de script. |
| IDataModelScriptDebugStackFrame | O provedor de script implementa essa interface para expor a noção de um quadro de pilha específico dentro da pilha de chamadas. |
| IDataModelScriptDebugVariableSetEnumerator | O provedor de script implementa essa interface para expor um conjunto de variáveis. Este conjunto pode representar o conjunto de parâmetros para uma função, o conjunto de variáveis locais ou o conjunto de variáveis dentro de um escopo específico. O significado exato depende de como a interface foi adquirida. |
| IDataModelScriptDebugBreakpoint | O provedor de script implementa essa interface para expor a noção e o controle de um ponto de interrupção específico dentro do script. |
| IDataModelScriptDebugBreakpointEnumerator | O provedor de script implementa isso para enumerar todos os pontos de interrupção que existem atualmente no script (habilitados ou não). |
O provedor de script principal: IDataModelScriptProvider
Qualquer extensão que deseje ser um provedor de script deve fornecer uma implementação da interface IDataModelScriptProvider e registrá-la com a parte do gerenciador de scripts do gerenciador de modelo de dados por meio do método RegisterScriptProvider. Esta interface central que deve ser implementada é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptProvider, IUnknown)
{
STDMETHOD(GetName)(_Out_ BSTR *name) PURE;
STDMETHOD(GetExtension)(_Out_ BSTR *extension) PURE;
STDMETHOD(CreateScript)(_COM_Outptr_ IDataModelScript **script) PURE;
STDMETHOD(GetDefaultTemplateContent)(_COM_Outptr_ IDataModelScriptTemplate **templateContent) PURE;
STDMETHOD(EnumerateTemplates)(_COM_Outptr_ IDataModelScriptTemplateEnumerator **enumerator) PURE;
}
O GetName método retorna o nome do tipo de (ou idioma de) scripts que o provedor gerencia como uma cadeia de caracteres alocada por meio do método SysAllocString. O chamador é responsável por liberar a string retornada via SysFreeString. Exemplos de strings que podem ser retornadas a partir deste método são "JavaScript" ou "NatVis". É provável que a cadeia de caracteres retornada apareça na interface do usuário do aplicativo depurador que está hospedando o modelo de dados. Não há dois provedores de script que retornem o mesmo nome (sem distinção entre maiúsculas e minúsculas).
O método GetExtension retorna a extensão de arquivo para scripts gerenciados por esse provedor (sem o ponto) como uma cadeia de caracteres alocada por meio do método SysAllocString. O aplicativo depurador que hospeda o modelo de dados (com suporte a scripts) delegará a abertura de arquivos de script com essa extensão ao provedor de scripts. O chamador é responsável por liberar a string retornada via SysFreeString. Exemplos de strings que podem ser retornadas a partir deste método são "js" ou "NatVis".
O método CreateScript é chamado para criar um novo script. O provedor de script deve retornar um script novo e vazio representado pela interface IDataModelScript retornada sempre que esse método for chamado. Observe que esse método é chamado independentemente de uma interface do usuário estar criando um novo script em branco para edição pelo usuário ou se o aplicativo depurador estiver carregando um script do disco. O provedor não se envolve na E/S de arquivos. Ele apenas lida com as solicitações do aplicativo de hospedagem por meio de fluxos passados para métodos em IDataModelScript.
O método GetDefaultTemplateContent retorna uma interface para o conteúdo do modelo padrão do provedor. Este é o conteúdo que o provedor de script gostaria de pré-preencher em uma janela de edição para um script recém-criado. Se o provedor de script não tiver modelos (ou não tiver conteúdo de modelo designado como o conteúdo padrão), o provedor de script poderá retornar E_NOTIMPL desse método.
O método EnumerateTemplates retorna um enumerador que é capaz de enumerar a variedade de modelos que são fornecidos pelo provedor de script. O conteúdo do modelo é o que o provedor de script deseja que seja "pré-preenchido" em uma janela de edição ao criar um novo script. Se houver vários modelos diferentes suportados, esses modelos podem ser nomeados (por exemplo: "Script Imperativo", "Script de Extensão") e o aplicativo depurador que hospeda o modelo de dados pode escolher como apresentar os "modelos" ao usuário.
a interface de script principal: IDataModelScript
A interface principal que gerencia um script individual que é implementado pelo provedor é a interface IDataModelScript. Um componente que implementa essa interface é retornado quando o cliente deseja criar um novo script em branco e chama o método CreateScript em IDataModelScriptProvider.
Cada script criado pelo provedor deve estar em um silo independente. Um script não deve ser capaz de afetar outro script, exceto por meio da interação explícita com objetos externos por meio do modelo de dados. Dois scripts, por exemplo, podem estender algum tipo ou conceito (por exemplo: a noção do depurador do que é um processo). Qualquer script pode então acessar os campos uns dos outros através do objeto de processo externo.
A interface é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScript, IUnknown)
{
STDMETHOD(GetName)(_Out_ BSTR *scriptName) PURE;
STDMETHOD(Rename)(_In_ PCWSTR scriptName) PURE;
STDMETHOD(Populate)(_In_ IStream *contentStream) PURE;
STDMETHOD(Execute)(_In_ IDataModelScriptClient *client) PURE;
STDMETHOD(Unlink)() PURE;
STDMETHOD(IsInvocable)(_Out_ bool *isInvocable) PURE;
STDMETHOD(InvokeMain)(_In_ IDataModelScriptClient *client) PURE;
}
O método GetName retorna o nome do script como uma cadeia de caracteres alocada por meio da função SysAllocString. Se o script ainda não tiver um nome, o método deverá retornar um BSTR nulo. Não deve falhar nesta circunstância. Se o script for explicitamente renomeado por meio de uma chamada para o método Rename, o método GetName deverá retornar o nome recém-atribuído.
O método Rename atribui um novo nome ao script. É responsabilidade da implementação do script salvar esse nome e retorná-lo em qualquer chamada para o método GetName. Isso geralmente é chamado quando uma interface do usuário escolhe Salvar como o script para um novo nome. Observe que renomear o script pode afetar onde o aplicativo de hospedagem escolhe projetar o conteúdo do script.
O método Populate é chamado pelo cliente para alterar ou sincronizar o "conteúdo" do script. É a notificação que é feita para o provedor de script que o código do script foi alterado. É importante observar que esse método não causa a execução do script ou alterações em qualquer um dos objetos que o script manipula. Isso é apenas uma notificação ao provedor de script de que o conteúdo do script foi alterado para que ele possa sincronizar seu próprio estado interno.
O método Execute executa o conteúdo do script conforme ditado pela última chamada Populate bem-sucedida e modifica o modelo de objeto do depurador de acordo com esse conteúdo. Se a linguagem (ou o provedor de script) define uma "função principal" - uma que o autor gostaria de chamar ao clicar em um botão imaginário "Executar Script" em uma interface do usuário - essa "função principal" não é chamada durante uma operação Executar. A operação Execute pode ser considerada apenas para executar manipulações de inicialização e modelo de objeto (por exemplo: executar código raiz e configurar pontos de extensibilidade).
O método Unlink desfaz a operação Execute. Todas as manipulações do modelo de objeto ou pontos de extensibilidade estabelecidos durante a execução do script são desfeitos. Após uma operação Desvincular, o script pode ser reexecutado por meio de uma chamada para Executar ou pode ser liberado.
O método IsInvocable retorna se o script é ou não invocável -- isto é, se ele tem uma "função principal" conforme definido por sua linguagem ou provedor. Tal "função principal" é conceitualmente algo que o autor do script gostaria de chamar se um botão imaginário "Executar Script" fosse pressionado em uma interface do usuário.
Se o script tem uma "função principal" que se destina a ser executada a partir de uma chamada de interface do usuário, ele indica isso por meio de um retorno verdadeiro do método IsInvocable. A interface do usuário pode então chamar o método InvokeMain para realmente "invocar" o script. Observe que isso é diferente do Execute que executa todo o código raiz e faz a ponte entre o script e o namespace do host subjacente.
**O cliente de script: IDataModelScriptClient **
Um aplicativo que hospeda o modelo de dados que deseja gerenciar scripts e ter uma interface de usuário (seja gráfica ou de console) em torno dessa noção implementa a interface IDataModelScriptClient. Essa interface é passada para qualquer provedor de script durante a execução ou invocação ou um script para passar informações de erro e evento de volta para a interface do usuário.
A interface IDataModelScriptClient é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptClient, IUnknown)
{
STDMETHOD(ReportError)(_In_ ErrorClass errClass, _In_ HRESULT hrFail, _In_opt_ PCWSTR message, _In_ ULONG line, _In_ ULONG position) PURE;
}
Se ocorrer um erro durante a execução ou invocação do script, o provedor de script chamará o método ReportError para notificar a interface do usuário do erro.
o contexto do host para um script: IDataModelScriptHostContext
O host de depuração tem alguma influência sobre como e onde projeta o conteúdo do script do modelo de dados. Espera-se que cada script peça ao host um contexto no qual colocar pontes para o script (por exemplo: objetos de função que podem ser chamados, etc...). Esse contexto é recuperado chamando o método CreateContext em IDebugHostScriptHost e obtendo um IDataModelScriptHostContext.
A interface IDataModelScriptHostContext é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptHostContext, IUnknown)
{
STDMETHOD(NotifyScriptChange)(_In_ IDataModelScript* script, _In_ ScriptChangeKind changeKind) PURE;
STDMETHOD(GetNamespaceObject)(_COM_Outptr_ IModelObject** namespaceObject) PURE;
}
É necessário que um provedor de script notifique o host de depuração em determinadas operações que ocorrem com uma chamada de método para o método NotifyScriptChange no contexto associado. Tais operações são definidas como membros da enumeração ScriptChangeKind
O GetNamespaceObject método retorna um objeto no qual o provedor de script pode colocar quaisquer pontes entre o modelo de dados e o script. É aqui, por exemplo, que o provedor de script pode colocar objetos de método de modelo de dados (interfaces IModelMethod encaixotadas em IModelObject) cuja implementação chama funções nomeadas correspondentemente no script.
Modelos para scripts recém-criados: IDataModelScriptTemplate
Os provedores de scripts que desejam apresentar conteúdo pré-preenchido para novos scripts (por exemplo: para ajudar os usuários a escrever scripts em uma interface de usuário do depurador) podem fazê-lo fornecendo um ou mais modelos de script. Esses modelos são componentes que implementam a interface IDataModelScriptTemplate e são retornados por meio do método GetDefaultTemplate ou do método EnumerateTemplates no provedor de script.
A interface IDataModelScriptTemplate é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptTemplate, IUnknown)
{
STDMETHOD(GetName)(_Out_ BSTR *templateName) PURE;
STDMETHOD(GetDescription)(_Out_ BSTR *templateDescription) PURE;
STDMETHOD(GetContent)(_COM_Outptr_ IStream **contentStream) PURE;
}
O método GetName retorna um nome do modelo. Isso pode falhar com E_NOTIMPL se o modelo não tiver um nome. O único modelo padrão (se existir) não é necessário para ter um nome. Todos os outros modelos são. Esses nomes podem ser apresentados em uma interface do usuário como parte de um menu para selecionar qual modelo deve ser criado.
O método GetDescription retorna uma descrição do modelo. Tal descrição seria apresentada ao usuário em interfaces mais descritivas para ajudar o usuário a entender para que o modelo foi projetado. O modelo pode retornar E_NOTIMPL deste método se ele não tiver uma descrição.
O método GetContent retorna o conteúdo (ou código) do modelo. Isso é o que seria pré-preenchido na janela de edição se um usuário optasse por criar um novo script a partir desse modelo. O modelo é responsável por criar (e retornar) um fluxo padrão sobre o conteúdo que o cliente pode extrair.
enumeração do conteúdo do modelo de um provedor: IDataModelScriptTemplateEnumerator
Um provedor de scripts pode fornecer um ou mais modelos que pré-preenchem o conteúdo em scripts recém-criados em alguma interface do usuário. Se qualquer um desses modelos for fornecido, o provedor de script deve implementar um enumerador sobre eles, que é retornado após uma chamada para o método EnumerateTemplates.
Esse enumerador é uma implementação da interface IDataModelScriptTemplateEnumerator e é definido da seguinte maneira.
DECLARE_INTERFACE_(IDataModelScriptTemplateEnumerator, IUnknown)
{
STDMETHOD(Reset)() PURE;
STDMETHOD(GetNext)(_COM_Outptr_ IDataModelScriptTemplate **templateContent) PURE;
}
O método Reset redefine o enumerador para a posição em que estava quando foi criado pela primeira vez -- antes do primeiro modelo produzido.
O método GetNext move o enumerador para o próximo modelo e o retorna. No final da enumeração, o enumerador retorna E_BOUNDS. Uma vez que o marcador de E_BOUNDS tenha sido atingido, o enumerador continuará a produzir erros de E_BOUNDS indefinidamente até que uma chamada Reset seja feita.
Resolvendo o significado dos nomes: IDataModelNameBinder
O modelo de dados fornece uma maneira padrão para os provedores de script determinarem o significado de um determinado nome em um determinado contexto (por exemplo: determinar o que barra significa para foo.bar) que operará em uma variedade de provedores de script. Esse mecanismo é conhecido como um fichário de nome e é representado pela interface IDataModelNameBinder. Esse fichário encapsula um conjunto de regras sobre como o nome é resolvido e como lidar com a resolução de conflitos em que um nome é definido várias vezes em um objeto. Parte dessas regras inclui coisas como como um nome projetado (adicionado por um modelo de dados) é resolvido em relação a um nome nativo (um no sistema de tipos do idioma que está sendo depurado).
Para fornecer um grau de consistência entre os provedores de script, o gerenciador de scripts do modelo de dados fornece um fichário de nome padrão'. Esse fichário de nome padrão pode ser adquirido por meio de uma chamada para o método GetDefaultNameBinder na interface IDataModelScriptManager. A interface do fichário de nomes é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelNameBinder, IUnknown)
{
STDMETHOD(BindValue)(_In_ IModelObject* contextObject, _In_ PCWSTR name, _COM_Errorptr_ IModelObject** value, _COM_Outptr_opt_result_maybenull_ IKeyStore** metadata) PURE;
STDMETHOD(BindReference)(_In_ IModelObject* contextObject, _In_ PCWSTR name, _COM_Errorptr_ IModelObject** reference, _COM_Outptr_opt_result_maybenull_ IKeyStore** metadata) PURE;
STDMETHOD(EnumerateValues)(_In_ IModelObject* contextObject, _COM_Outptr_ IKeyEnumerator** enumerator) PURE;
STDMETHOD(EnumerateReferences)(_In_ IModelObject* contextObject, _COM_Outptr_ IKeyEnumerator** enumerator) PURE;
}
O BindValue método executa o equivalente a contextObject.name no objeto dado de acordo com um conjunto de regras de vinculação. O resultado dessa vinculação é um valor. Como um valor, o provedor de script subjacente não pode usar o valor para executar a atribuição de volta ao nome.
O método BindReference é semelhante a BindValue na medida em que também executa o equivalente a contextObject.name no objeto dado de acordo com um conjunto de regras de vinculação. O resultado da ligação deste método é, no entanto, uma referência em vez de um valor. Como referência, o provedor de script pode utilizar a referência para executar a atribuição de volta ao nome.
O método EnumerateValues enumera o conjunto de nomes e valores que serão vinculados ao objeto de acordo com as regras do método BindValue. Ao contrário de EnumerateKeys, EnumerateValues e métodos semelhantes em IModelObject que podem retornar vários nomes com o mesmo valor (para classes base, modelos pai e similares), este enumerador só retornará o conjunto específico de nomes que serão vinculados com BindValue e BindReference. Os nomes nunca serão duplicados. Observe que há um custo significativamente maior de enumerar um objeto por meio do fichário de nome do que chamar os métodos IModelObject.
O método EnumerateReferences enumera o conjunto de nomes e referências a eles que serão vinculados ao objeto de acordo com as regras do método BindReference. Ao contrário de EnumerateKeys, EnumerateValues e métodos semelhantes em IModelObject que podem retornar vários nomes com o mesmo valor (para classes base, modelos pai e similares), este enumerador só retornará o conjunto específico de nomes que serão vinculados com BindValue e BindReference. Os nomes nunca serão duplicados. Observe que há um custo significativamente maior de enumerar um objeto por meio do fichário de nome do que chamar os métodos IModelObject.
Interfaces de depuração de script C++ do modelo de dados do Depurador
A infraestrutura para provedores de script no modelo de dados também fornece um conceito sobre depuração de scripts. Qualquer script que deseje expor os recursos de depuração ao host de depuração e ao aplicativo depurador que hospeda o modelo de dados pode fazê-lo fazendo com que scripts depuráveis implementem a interface IDataModelScriptDebug, além da interface IDataModelScript. A presença dessa interface no script indica à infraestrutura que ela é depurável.
Embora a interface IDataModelScriptDebug seja o ponto de partida para obter acesso aos recursos de depuração de um provedor de script, ela é unida por um conjunto de outras interfaces no fornecimento de recursos gerais de depuração.
As interfaces de depuração são:
| Interfaz | Descrição |
|---|---|
| IDataModelScriptDebug | A interface principal que um provedor de script deve fornecer para tornar um script depurável. A classe de implementação da interface IDataModelScript deve QueryInterface for IDataModelScriptDebug se o script for depurável. |
| IDataModelScriptDebugClient | A interface do usuário que deseja fornecer a capacidade de depuração de script implementa a interface IDataModelScriptDebugClient. O provedor de script utiliza essa interface para passar informações de depuração para frente e para trás (por exemplo: eventos que ocorrem, pontos de interrupção, etc...) |
| IDataModelScriptDebugStack | O provedor de script implementa essa interface para expor a noção de uma pilha de chamadas para o depurador de script. |
| IDataModelScriptDebugStackFrame | O provedor de script implementa essa interface para expor a noção de um quadro de pilha específico dentro da pilha de chamadas. |
| IDataModelScriptDebugVariableSetEnumerator | O provedor de script implementa essa interface para expor um conjunto de variáveis. Este conjunto pode representar o conjunto de parâmetros para uma função, o conjunto de variáveis locais ou o conjunto de variáveis dentro de um escopo específico. O significado exato depende de como a interface foi adquirida. |
| IDataModelScriptDebugBreakpoint | O provedor de script implementa essa interface para expor a noção e o controle de um ponto de interrupção específico dentro do script. |
| IDataModelScriptDebugBreakpointEnumerator | O provedor de script implementa isso para enumerar todos os pontos de interrupção que existem atualmente no script (habilitados ou não). |
As interfaces gerais de gestão são:
| Interfaz | Descrição |
|---|---|
| IDataModelScriptProvider | A interface principal que um provedor de script deve implementar. Esta é a interface que é registrada com a parte do gerenciador de scripts do gerenciador de modelo de dados, a fim de anunciar o suporte do provedor de um determinado tipo de script e registrar em relação a uma extensão de arquivo específica |
| IDataModelScript | Uma abstração de um script específico que está sendo gerenciado pelo provedor. Cada script que está sendo carregado ou sendo editado tem uma instância IDataModelScript separada |
| IDataModelScriptClient | Uma interface de cliente que é usada pelo provedor de script para comunicar informações a uma interface do usuário. Os provedores de script não implementam essa interface. O aplicativo que hospeda o modelo de dados que deseja fazer uso de provedores de script faz. Um provedor de script chamará métodos do cliente de script para relatar status, erros, etc... |
| IDataModelScriptHostContext | Uma interface de host que é usada pelo provedor de script como um contêiner para o conteúdo do script. Como o conteúdo de uma superfície de script diferente das manipulações que ele executa no modelo de objeto do aplicativo depurador depende do host de depuração específico. Essa interface permite que o provedor de scripts obtenha informações sobre onde colocar seu conteúdo. |
| IDataModelScriptTemplate | Os provedores de scripts podem fornecer um ou mais modelos que servem como pontos de partida para os usuários criarem scripts. Um aplicativo depurador que fornece um editor embutido pode pré-preencher novos scripts com conteúdo de modelo, conforme anunciado pelo provedor através desta interface. |
| IDataModelScriptTemplateEnumerator | Uma interface de enumerador que o provedor de script implementa para anunciar todos os vários modelos suportados. |
| IDataModelNameBinder | Um fichário de nome -- um objeto que pode associar um nome em um contexto a um valor. Para uma determinada expressão como "foo.bar", um fichário de nome é capaz de vincular o nome "barra" no contexto do objeto "foo" e produzir um valor ou referência a ele. Os fichários de nomes normalmente não são implementados por um provedor de script; em vez disso, o fichário padrão pode ser adquirido do modelo de dados e usado pelo provedor de script. |
Tornando os scripts depuráveis: IDataModelScriptDebug
Qualquer script depurável indica esse recurso por meio da presença da interface IDataModelScriptDebug no mesmo componente que implementa IDataModelScript. A consulta para essa interface pelo host de depuração ou pelo aplicativo depurador que hospeda o modelo de dados é o que indica a presença do recurso de depuração.
A interface IDataModelScriptDebug é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptDebug, IUnknown)
{
STDMETHOD_(ScriptDebugState, GetDebugState)() PURE;
STDMETHOD(GetCurrentPosition)(_Out_ ScriptDebugPosition *currentPosition, _Out_opt_ ScriptDebugPosition *positionSpanEnd, _Out_opt_ BSTR *lineText) PURE;
STDMETHOD(GetStack)(_COM_Outptr_ IDataModelScriptDebugStack **stack) PURE;
STDMETHOD(SetBreakpoint)(_In_ ULONG linePosition, _In_ ULONG columnPosition, _COM_Outptr_ IDataModelScriptDebugBreakpoint **breakpoint) PURE;
STDMETHOD(FindBreakpointById)(_In_ ULONG64 breakpointId, _COM_Outptr_ IDataModelScriptDebugBreakpoint **breakpoint) PURE;
STDMETHOD(EnumerateBreakpoints)(_COM_Outptr_ IDataModelScriptDebugBreakpointEnumerator **breakpointEnum) PURE;
STDMETHOD(GetEventFilter)(_In_ ScriptDebugEventFilter eventFilter, _Out_ bool *isBreakEnabled) PURE;
STDMETHOD(SetEventFilter)(_In_ ScriptDebugEventFilter eventFilter, _In_ bool isBreakEnabled) PURE;
STDMETHOD(StartDebugging)(_In_ IDataModelScriptDebugClient *debugClient) PURE;
STDMETHOD(StopDebugging)(_In_ IDataModelScriptDebugClient *debugClient) PURE;
}
O método GetDebugState retorna o estado atual do script (por exemplo: se ele está sendo executado ou não). O estado é definido por um valor dentro da enumeração ScriptDebugState.
O método GetCurrentPosition' retorna a posição atual dentro do script. Isso só pode ser chamado quando o script é quebrado no depurador, onde uma chamada para GetScriptState retornaria ScriptDebugBreak. Qualquer outra chamada para este método é inválida e falhará.
O método GetStack obtém a pilha de chamadas atual na posição de interrupção. Este método só pode ser chamado quando o script é quebrado no depurador.
O método SetBreakpoint define um ponto de interrupção dentro do script. Observe que a implementação é livre para ajustar as posições da linha e da coluna passadas para avançar para uma posição de código apropriada. Os números reais de linha e coluna onde o ponto de interrupção foi colocado podem ser recuperados por chamadas de método na interface IDataModelScriptDebugBreakpoint retornada.
Cada ponto de interrupção criado dentro do script por meio do método SetBreakpoint recebe um identificador exclusivo (um inteiro não assinado de 64 bits) pela implementação. O método FindBreakpointById é usado para obter uma interface para o ponto de interrupção de um determinado identificador.
O método EnumerateBreakpoints retorna um enumerador capaz de enumerar cada ponto de interrupção definido em um script específico.
O método GetEventFilter retorna se "break on event" está habilitado para um evento específico. Os eventos que podem causar "quebra no evento" são descritos por um membro da enumeração ScriptDebugEventFilter.
O método SetEventFilter altera o comportamento "break on event" para um evento específico, conforme definido por um membro da enumeração ScriptDebugEventFilter. Uma lista completa de eventos disponíveis (e uma descrição dessa enumeração) pode ser encontrada na documentação do método GetEventFilter.
O método StartDebugging "ativa" o depurador para um script específico. O ato de iniciar a depuração não causa ativamente nenhuma quebra ou revisão de execução. Ele apenas torna o script depurável e fornece um conjunto de interfaces para o cliente se comunicar com a interface de depuração.
O método StopDebugging é chamado por um cliente que deseja parar a depuração. Esta chamada de método pode ser feita a qualquer momento depois que StartDebugging foi feito com sucesso (por exemplo: durante uma pausa, enquanto o script está em execução, etc...). A chamada cessa imediatamente toda a atividade de depuração e redefine o estado de volta para antes de StartDebugging ter sido chamado.
A interface de depuração: IDataModelScriptDebugClient
O host de depuração ou aplicativo depurador que deseja fornecer uma interface em torno da depuração de script deve fornecer uma implementação da interface IDataModelScriptDebugClient para o depurador de script por meio do método StartDebugging na interface de depuração para o script.
O IDataModelScriptDebugClient é o canal de comunicação através do qual os eventos de depuração são passados e o controle vai do mecanismo de execução de script para uma interface do depurador. Define-se da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptDebugClient, IUnknown)
{
STDMETHOD(NotifyDebugEvent)(_In_ ScriptDebugEventInformation *pEventInfo, _In_ IDataModelScript *pScript, _In_opt_ IModelObject *pEventDataObject, _Inout_ ScriptExecutionKind *resumeEventKind) PURE;
}
Sempre que ocorre algum evento que invade o depurador de script, o próprio código de depuração faz uma chamada para a interface por meio do método NotifyDebugEvent. Este método é síncrono. Nenhuma execução do script será retomada até que a interface retorne do evento. A definição do depurador de script pretende ser simples: não há absolutamente nenhum evento aninhado que exija processamento. Um evento de depuração é definido por um registro variante conhecido como ScriptDebugEventInformation. Quais campos nas informações do evento são válidos é amplamente definido pelo membro DebugEvent. Ele define o tipo de evento que ocorreu conforme descrito por um membro da enumeração ScriptDebugEvent.
a pilha de chamadas: IDataModelScriptDebugStack
Quando ocorre um evento que invade o depurador de script, a interface de depuração desejará recuperar a pilha de chamadas para o local de interrupção. Isso é feito por meio do método GetStack. Essa pilha é expressa através do IDataModelScriptDebugStack que é definido como indicado abaixo.
Observe que a pilha geral pode abranger vários scripts e/ou vários provedores de script. A pilha de chamadas que é retornada de uma única chamada para o método GetStack na interface de depuração de um script específico só deve retornar o segmento da pilha de chamadas dentro dos limites desse script. É totalmente possível que um mecanismo de depuração de script possa recuperar a pilha de chamadas, pois abrange vários contextos de script se dois scripts do mesmo provedor interagirem. O método GetStack não deve retornar a parte da pilha que está em outro script. Em vez disso, se essa situação puder ser detetada, o quadro de pilha que é o quadro de limite no script deve marcar-se como um quadro de transição por meio de uma implementação dos métodos IsTransitionPoint e GetTransition nesse quadro de pilha. Espera-se que a interface do depurador una a pilha geral dos vários segmentos de pilha que existem.
É imperativo que as transições sejam implementadas dessa maneira ou a interface de depuração pode direcionar consultas sobre variáveis locais, parâmetros, pontos de interrupção e outras construções específicas de script para o contexto de script errado! Isso resultará em um comportamento indefinido na interface do depurador.
DECLARE_INTERFACE_(IDataModelScriptDebugStack, IUnknown)
{
STDMETHOD_(ULONG64, GetFrameCount)() PURE;
STDMETHOD(GetStackFrame)(_In_ ULONG64 frameNumber, _COM_Outptr_ IDataModelScriptDebugStackFrame **stackFrame) PURE;
}
O GetFrameCount método retorna o número de quadros de pilha neste segmento da pilha de chamadas. Se o provedor puder detetar quadros em contextos de script diferentes ou de provedores diferentes, ele deverá indicar isso ao chamador implementando os métodos IsTransitionPoint e GetTransition no quadro de entrada neste segmento de pilha.
O GetStackFrame obtém um quadro de pilha específico do segmento de pilha. A pilha de chamadas tem um sistema de indexação baseado em zero: o quadro de pilha atual onde ocorreu o evento de quebra é o quadro 0. O chamador do método atual é o quadro 1 (e assim por diante).
Estado de exame quando quebrado: IDataModelScriptDebugStackFrame
Um quadro específico da pilha de chamadas quando quebrado no depurador de script pode ser recuperado por meio de uma chamada para o método GetStackFrame na interface IDataModelScriptDebugStack que representa o segmento de pilha onde a quebra ocorreu. A interface IDataModelScriptDebugStackFrame que é retornada para representar esse quadro é definida da seguinte maneira.
DECLARE_INTERFACE_(IDataModelScriptDebugStackFrame, IUnknown)
{
STDMETHOD(GetName)(_Out_ BSTR *name) PURE;
STDMETHOD(GetPosition)(_Out_ ScriptDebugPosition *position, _Out_opt_ ScriptDebugPosition *positionSpanEnd, _Out_opt_ BSTR *lineText) PURE;
STDMETHOD(IsTransitionPoint)(_Out_ bool *isTransitionPoint) PURE;
STDMETHOD(GetTransition)(_COM_Outptr_ IDataModelScript **transitionScript, _Out_ bool *isTransitionContiguous) PURE;
STDMETHOD(Evaluate)(_In_ PCWSTR pwszExpression, _COM_Outptr_ IModelObject **ppResult) PURE;
STDMETHOD(EnumerateLocals)(_COM_Outptr_ IDataModelScriptDebugVariableSetEnumerator **variablesEnum) PURE;
STDMETHOD(EnumerateArguments)(_COM_Outptr_ IDataModelScriptDebugVariableSetEnumerator **variablesEnum) PURE;
}
O método GetName retorna o nome para exibição (por exemplo: nome da função) desse quadro. Esse nome será exibido dentro do backtrace de pilha apresentado ao usuário na interface do depurador.
O GetPosition método retorna a posição dentro do script representado pelo quadro de pilha. Esse método só pode ser chamado quando o script está dentro de uma quebra representada pela pilha na qual esse quadro está contido. A posição da linha e da coluna dentro deste quadro é sempre retornada. Se o depurador for capaz de retornar a extensão da "posição de execução" dentro do script, uma posição final poderá ser retornada no argumento positionSpanEnd. Se o depurador não for capaz disso, os valores de linha e coluna no final da extensão (se solicitado) devem ser definidos como zero.
A interface IDataModelScriptDebugStack representa um segmento de uma pilha de chamadas -- a parte da pilha de chamadas que está contida no contexto de um script. Se o depurador for capaz de detetar a transição de um script para outro (ou um provedor de script para outro), ele poderá indicar isso implementando o método IsTransitionPoint e retornando true ou false conforme apropriado. O quadro da pilha de chamadas que entrou no script onde o segmento se aplica deve ser considerado um ponto de transição. Todos os outros quadros não são.
Se um determinado quadro de pilha for um ponto de transição conforme determinado pelo método IsTransition (consulte a documentação para obter uma definição de pontos de transição), o método GetTransition retornará informações sobre a transição. Em particular, esse método retorna o script anterior -- aquele que fez uma chamada no script representado pelo segmento de pilha que contém este IDataModelScriptDebugStackFrame.
O método Evaluate avalia uma expressão (da linguagem do provedor de script) no contexto do quadro de pilha representado pela interface IDataModelScriptDebugStackFrame na qual esse método foi chamado. O resultado da avaliação de expressão deve ser empacotado fora do provedor de script como um IModelObject. As propriedades e outras construções no IModelObject resultante devem ser capazes de ser adquiridas enquanto o depurador está em um estado de interrupção.
O método EnumerateLocals retorna um conjunto de variáveis (representado por uma interface IDataModelScriptDebugVariableSetEnumerator) para todas as variáveis locais que estão no escopo no contexto do quadro de pilha representado pela interface IDataModelScriptDebugStackFrame na qual esse método foi chamado.
O método EnumerateArguments retorna um conjunto de variáveis (representado por uma interface IDataModelScriptDebugVariableSetEnumerator) para todos os argumentos de função da função chamada no quadro de pilha representado pela interface IDataModelScriptDebugStackFrame na qual esse método foi chamado.
Examinando variáveis: IDataModelScriptDebugVariableSetEnumerator
Um conjunto de variáveis no script que está sendo depurado (sejam aquelas em um escopo específico, os locais de uma função, os argumentos de uma função, etc...) é representado por um conjunto de variáveis definido através da interface IDataModelScriptDebugVariableSetEnumerator:
DECLARE_INTERFACE_(IDataModelScriptDebugVariableSetEnumerator, IUnknown)
{
STDMETHOD(Reset)() PURE;
STDMETHOD(GetNext)(_Out_ BSTR *variableName, _COM_Outptr_opt_ IModelObject **variableValue, _COM_Outptr_opt_result_maybenull_ IKeyStore **variableMetadata) PURE;
}
O método Reset redefine a posição do enumerador para onde estava imediatamente após a criação -- ou seja, antes do primeiro elemento do conjunto.
O método GetNext move o enumerador para a próxima variável no conjunto e retorna o nome, o valor e quaisquer metadados associados a ela da variável. Se o enumerador tiver atingido o final do conjunto, o E_BOUNDS de erro será retornado. Depois que o marcador E_BOUNDS tiver sido retornado do método GetNext, ele continuará a produzir E_BOUNDS quando chamado novamente, a menos que uma chamada Reset interveniente seja feita.
pontos de interrupção: IDataModelScriptDebugBreakpoint
Os pontos de interrupção de script são definidos por meio do método SetBreakpoint na interface de depuração de um determinado script. Esses pontos de interrupção são representados por uma id exclusiva e uma implementação da interface IDataModelScriptDebugBreakpoint, que é definida da seguinte forma.
DECLARE_INTERFACE_(IDataModelScriptDebugBreakpoint, IUnknown)
{
STDMETHOD_(ULONG64, GetId)() PURE;
STDMETHOD_(bool, IsEnabled)() PURE;
STDMETHOD_(void, Enable)() PURE;
STDMETHOD_(void, Disable)() PURE;
STDMETHOD_(void, Remove)() PURE;
STDMETHOD(GetPosition)(_Out_ ScriptDebugPosition *position, _Out_opt_ ScriptDebugPosition *positionSpanEnd, _Out_opt_ BSTR *lineText) PURE;
}
O método GetId retorna o identificador exclusivo atribuído pelo mecanismo de depuração do provedor de script para o ponto de interrupção. Esse identificador deve ser exclusivo dentro do contexto do script que contém. O identificador de ponto de interrupção pode ser exclusivo para o provedor; no entanto, isso não é necessário.
O método IsEnabled retorna se o ponto de interrupção está habilitado ou não. Um ponto de interrupção desativado ainda existe e ainda está na lista de pontos de interrupção para o script, ele é meramente "desligado" temporariamente. Todos os pontos de interrupção devem ser criados no estado habilitado.
O método Enable habilita o ponto de interrupção. Se o ponto de interrupção foi desativado, "bater o ponto de interrupção" depois de chamar esse método causará uma quebra no depurador.
O método Disable desativa o ponto de interrupção. Após essa chamada, "atingir o ponto de interrupção" depois de chamar esse método não invadirá o depurador. O ponto de interrupção, embora ainda presente, é considerado "desligado".
O método Remove remove o ponto de interrupção de sua lista de contenção. O ponto de interrupção não existe mais semanticamente depois que esse método retorna. A interface IDataModelScriptDebugBreakpoint que representou o ponto de interrupção é considerada órfã após a chamada. Nada mais pode (legalmente) ser feito com ele após esta chamada além de liberá-lo.
O método GetPosition retorna a posição do ponto de interrupção dentro do script. O depurador de script deve retornar a linha e a coluna dentro do código-fonte onde o ponto de interrupção está localizado. Se ele for capaz de fazer isso, ele também pode retornar uma extensão de origem representada pelo ponto de interrupção preenchendo uma posição final conforme definido pelo argumento positionSpanEnd. Se o depurador não for capaz de produzir essa extensão e o chamador solicitá-la, os campos Linha e Coluna da posição final da extensão deverão ser preenchidos como zero, indicando que os valores não podem ser fornecidos.
Enumeração de ponto de interrupção: IDataModelScriptDebugBreakpointEnumerator
Se um provedor de script oferecer suporte à depuração, ele também deverá acompanhar todos os pontos de interrupção associados a cada script e ser capaz de enumerar esses pontos de interrupção para a interface de depuração. O enumerador para pontos de interrupção é adquirido por meio do método EnumerateBreakpoints na interface de depuração para um determinado script e é definido da seguinte maneira.
DECLARE_INTERFACE_(IDataModelScriptDebugBreakpointEnumerator, IUnknown)
{
STDMETHOD(Reset)() PURE;
STDMETHOD(GetNext)(_COM_Outptr_ IDataModelScriptDebugBreakpoint **breakpoint) PURE;
}
O método Reset redefine a posição do enumerador para onde ele estava logo após o enumerador ter sido criado -- ou seja, antes do primeiro ponto de interrupção enumerado.
O método GetNext move o enumerador para o próximo ponto de interrupção a ser enumerado e retorna a interface IDataModelScriptDebugBreakpoint para esse ponto de interrupção. Se o enumerador tiver chegado ao final da enumeração, ele retornará E_BOUNDS. Uma vez que o erro E_BOUNDS tenha sido produzido, as chamadas subsequentes para o método GetNext continuarão a produzir E_BOUNDS a menos que uma chamada interveniente para o método Reset tenha sido feita.
Ver também
Este tópico faz parte de uma série que descreve as interfaces acessíveis a partir de C++, como usá-las para criar uma extensão de depurador baseada em C++ e como fazer uso de outras construções de modelo de dados (por exemplo: JavaScript ou NatVis) a partir de uma extensão de modelo de dados C++.
Visão geral do Depurador Data Model C++
Depurador Data Model C++ Interfaces
Depurador Data Model C++ Objects