My 2016 GSoC Project - Part XIV

content = {
    # The code context in which introspection is requested
    # this may be up to an entire multiline cell.
    'code' : str,

    # The cursor position within 'code' (in unicode characters) where inspection is requested
    'cursor_pos' : int,

    # The level of detail desired.  In IPython, the default (0) is equivalent to typing
    # 'x?' at the prompt, 1 is equivalent to 'x??'.
    # The difference is up to kernels, but in IPython level 1 includes the source code
    # if available.
    'detail_level' : 0 or 1,
}

content = {
    # 'ok' if the request succeeded or 'error', with error information as in all other replies.
    'status' : 'ok',

    # found should be true if an object was found, false otherwise
    'found' : bool,

    # data can be empty if nothing is found
    'data' : dict,
    'metadata' : dict,
}

#include "symbol.hxx"         // Variable symbol (identifier) class
#include "context.hxx"        // Context (state holding variables) class
#include "internal.hxx"       // Internal generic Scilab type class 

void JupyterKernel::HandleInspectionRequest( Json::Value& commandContent, Json::Value& replyContent )
{
  std::string code = commandContent.get( "code", "" ).asString();
  int cursorPosition = commandContent.get( "cursor_pos", 0 ).asInt();
  // Not differentiating between levels of detail so far
  int detailLevel = commandContent.get( "detail_level", 0 ).asInt();
  
  // Consider the searched variable name/symbol the word 
  // (between spaces) over which the cursor is located
  size_t variableNameStartPosition = code.substr( 0, cursorPosition ).find_last_of( " \n\r\t" );
  if( variableNameStartPosition == std::string::npos ) variableNameStartPosition = 0;
  else variableNameStartPosition += 1;
  size_t variableNameEndPosition = code.substr( cursorPosition ).find_first_of( " \n\r\t" );
  
  std::string variableName = code.substr( variableNameStartPosition, variableNameEndPosition );
  
  // A symbol is defined by a wide string (more than 8 bits per character)
  // So we perform a format conversion
  symbol::Symbol variableSymbol( std::wstring( variableName.begin(), variableName.end() ) );
  // Scilab's context object is a single instance (singleton) shared accross the entire aplication
  types::InternalType* variableType = symbol::Context::getInstance()->get( variableSymbol );
  
  replyContent[ "status" ] = "ok";
  replyContent[ "found" ] = false;
  replyContent[ "data" ] = Json::Value( Json::objectValue );
  replyContent[ "metadata" ] = Json::Value( Json::objectValue );
  
  if( variableType != NULL ) 
  {
    replyContent[ "found" ] = true;
    // For now, we only acquire the variable type string identifier
    std::wstring typeWString = variableType->getTypeStr();
    replyContent[ "data" ][ "Type" ] = std::string( typeWString.begin(), typeWString.end() );
  }
}

content = {
    # The code context in which completion is requested
    # this may be up to an entire multiline cell, such as
    # 'foo = a.isal'
    'code' : str,

    # The cursor position within 'code' (in unicode characters) where completion is requested
    'cursor_pos' : int,
}

content = {
    # The list of all matches to the completion request, such as
    # ['a.isalnum', 'a.isalpha'] for the above example.
    'matches' : list,

    # The range of text that should be replaced by the above matches when a completion is accepted.
    # typically cursor_end is the same as cursor_pos in the request.
    'cursor_start' : int,
    'cursor_end' : int,

    # Information that frontend plugins might use for extra display information about completions.
    'metadata' : dict,

    # status should be 'ok' unless an exception was raised during the request,
    # in which case it should be 'error', along with the usual error message content
    # in other messages.
    'status' : 'ok'
}

extern "C" {
  #include "completion.h"               // Scilab's completion has only a C interface
}

void JupyterKernel::HandleCompletionRequest( Json::Value& commandContent, Json::Value& replyContent )
{
  std::string code = commandContent.get( "code", "" ).asString();
  int cursorPosition = commandContent.get( "cursor_pos", 0 ).asInt();
  
  // Consider the searched token only the substring of the code after
  // the last space character and before the cursor position
  code.resize( cursorPosition, ' ' );
  size_t tokenStartPosition = code.find_last_of( " \n\r\t" );
  if( tokenStartPosition == std::string::npos ) tokenStartPosition = 0;
  else tokenStartPosition += 1;
  std::string token = code.substr( tokenStartPosition );
  
  int completionMatchesCount = 0;
  // Scilab internal call that returns the list of matching strings (char pointers)
  char** completionMatches = completion( (const char*) token.data(), &completionMatchesCount );
  
  // Create and fill the returning dictionary
  replyContent[ "matches" ] = Json::Value( Json::arrayValue );
  for( int matchIndex = 0; matchIndex < completionMatchesCount; matchIndex++ )
    replyContent[ "matches" ][ matchIndex ] = std::string( completionMatches[ matchIndex ] );
  
  replyContent[ "cursor_start" ] = (int) tokenStartPosition;
  replyContent[ "cursor_end" ] = cursorPosition;
  replyContent[ "metadata" ] = Json::Value( Json::objectValue );
  replyContent[ "status" ] = "ok";
}

content = {
    # The code entered so far as a multiline string
    'code' : str,
}

content = {
    # One of 'complete', 'incomplete', 'invalid', 'unknown'
    'status' : str,

    # If status is 'incomplete', indent should contain the characters to use
    # to indent the next line. This is only a hint: frontends may ignore it
    # and use their own autoindentation rules. For other statuses, this
    # field does not exist.
    'indent': str,
}

#include "parser.hxx"

void JupyterKernel::HandleCompletenessRequest(Json::Value& commandContent, Json::Value& replyContent)
{
  // Independent parser (not the engine's one)
  // "static" so that previous state is kept
  static Parser checker;
  
  std::string code = commandContent.get( "code", "" ).asString();
  
  checker.parse( code.data() ); // Verify code without submitting it to the engine
  
  bool isComplete = false;
  replyContent[ "status" ] = "incomplete"; // when "unknown" ?
  if( checker.getControlStatus() == Parser::ControlStatus::AllControlClosed )
  {
    // An invalid command also exits control blocks
    isComplete = true;
    if( checker.getExitStatus() == Parser::ParserStatus::Succeded ) // typo
      replyContent[ "status" ] = "complete";
    else
    {
      replyContent[ "status" ] = "invalid";
      checker.cleanup();
    }
  }
  
  // Frontends like QtConsole use their own prompt string and appends 
  // the received one to the code, so this should be empty
  if( not isComplete ) replyContent[ "indent" ] = "";
}