SystemCallPrintSystemCalls.cpp

Go to the documentation of this file.

 
#ifndef _MADARA_NO_KARL_
 
#include "madara/expression/LeafNode.h"
#include "madara/expression/SystemCallPrintSystemCalls.h"
#include "madara/expression/Visitor.h"
#include "madara/knowledge/ThreadSafeContext.h"
 
// a map of all the system calls to their help information.
madara::expression::SystemCallsHelp
    madara::expression::SystemCallPrintSystemCalls::calls_;
 
madara::expression::SystemCallPrintSystemCalls::SystemCallPrintSystemCalls(
    madara::knowledge::ThreadSafeContext& context, const ComponentNodes& nodes)
  : SystemCallNode(context, nodes)
{
}
 
// Dtor
madara::expression::SystemCallPrintSystemCalls::~SystemCallPrintSystemCalls(
    void)
{
}
 
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallPrintSystemCalls::item(void) const
{
  return madara::knowledge::KnowledgeRecord(1);
}
 
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallPrintSystemCalls::prune(bool& can_change)
{
  // user can always change a function, and we have no control over
  // what it does. Consequently, a function node cannot be pruned out
  // under any situation
  can_change = true;
 
  madara::knowledge::KnowledgeRecord result;
 
  if (nodes_.size() == 1)
  {
    bool arg_can_change = false;
    result = nodes_[0]->prune(arg_can_change);
 
    if (!arg_can_change && dynamic_cast<LeafNode*>(nodes_[0]) == 0)
    {
      delete nodes_[0];
      nodes_[0] = new LeafNode(*(this->logger_), result);
    }
  }
  else if (nodes_.size() != 0)
  {
    madara_logger_ptr_log(logger_, logger::LOG_ERROR,
        "madara::expression::SystemCallPrintSystemCalls: "
        "KARL COMPILE ERROR:"
        "System call print_system_calls takes either 0"
        " or 1 arguments\n");
 
    throw exceptions::KarlException(
        "madara::expression::SystemCallPrintSystemCalls: "
        "KARL COMPILE ERROR: "
        "System call print_system_calls takes either 0"
        " or 1 arguments\n");
  }
 
  // if calls hasn't been initialized yet, fill the list of system calls
  if (calls_.size() == 0)
  {
    calls_["#clear_variable"] =
        "\n#clear_var (var) or #clear_variable (var):\n"
        "  Clears the variable var in the knowledge base. This is\n"
        "  the preferred way to delete variables. It masks the variable\n"
        "  from printouts and save_modifieds but leaves a phantom record\n"
        "  in the knowledge base to safely reference in VariableReference,\n"
        "  CompiledExpression, etc.\n";
 
    calls_["#cos"] = "\n#cos (var):\n"
                     "  Returns the cosine of a term (radians)\n";
 
    calls_["#delete_variable"] =
        "\n#delete_var (var) or #delete_variable (var):\n"
        "  Deletes a variable named var from the knowledge base. \n"
        "  This is an extremely unsafe operation that must only\n"
        "  be used if the variable is never used in compiled\n"
        "  expressions or variable references (including container\n"
        "  classes such as Integer, Double, Vector, etc.)\n";
 
    calls_["#eval"] =
        "\n#eval (expression) or #evaluate (expression):\n"
        "  Evaluates the KaRL expression and returns a result. Works "
        "similarly\n"
        "  to the KnowledgeBase::evaluate function except this function\n"
        "  inherits the KnowledgeUpdateSettings from the eval call.\n";
 
    calls_["#evaluate"] =
        "\n#eval (expression) or #evaluate (expression):\n"
        "  Evaluates the KaRL expression and returns a result. Works "
        "similarly\n"
        "  to the KnowledgeBase::evaluate function except this function\n"
        "  inherits the KnowledgeUpdateSettings from the eval call.\n";
 
    calls_["#expand"] =
        "\n#expand (statement) or #expand_statement (statement):\n"
        "  Expands a statement such as 'var{.i}' into 'var0', assuming .i=0\n";
 
    calls_["#expand_env"] =
        "\n#expand_env (statement) or #expand_envs (statement):\n"
        "  Expands a statement such as 'env_var=$(VAR)' into\n"
        "  env_var=VAR CONTENTS, assuming VAR has been set in the OS.\n";
 
    calls_["#expand_envs"] =
        "\n#expand_env (statement) or #expand_envs (statement):\n"
        "  Expands a statement such as 'env_var=$(VAR)' into\n"
        "  env_var=VAR CONTENTS, assuming VAR has been set in the OS.\n";
 
    calls_["#expand_statement"] =
        "\n#expand (statement) or #expand_statement (statement):\n"
        "  Expands a statement such as 'var{.i}' into 'var0', assuming .i=0\n";
 
    calls_["#fragment"] =
        "\n#fragment (arg, first, last):\n"
        "  Returns a fragment of the arg, startin at first byte and extending\n"
        "  to last byte.\n";
 
    calls_["#get_clock"] =
        "\n#get_clock () or #get_clock (variable):\n"
        "  Returns either the system clock or the variable clock. Note that\n"
        "  this is a Lamport clock value and not a wall time value.\n";
 
    calls_["#get_time"] =
        "\n#get_time () or #get_time_ns() or #get_time_nano():\n"
        "  Returns wall clock time on the local machine in nanoseconds.\n";
 
    calls_["#get_time_seconds"] =
        "\n#get_time_seconds () or #get_time_s ():\n"
        "  Returns wall clock time on the local machine in seconds.\n";
 
    calls_["#isinf"] =
        "\n#isinf (value):\n"
        "  Returns std::isinf of a value to check for infinity/-infinity.\n";
 
    calls_["#log_level"] =
        "\n#log_level () or #log_level (value):\n"
        "  Returns the logging level or sets the logging level. The logging\n"
        "  level determines the granularity of MADARA log messages. The value\n"
        "  should be an integer from 0-6.\n"
        "  0: Emergency or always messages. Default setting.\n"
        "  1. Errors\n"
        "  2. Warnings\n"
        "  3. Major events\n"
        "  4. Minor events\n"
        "  5. Trace events\n"
        "  6. Detailed logging\n";
 
    calls_["#pow"] = "\n#pow (base, power):\n"
                     "  Returns the base taken to a power (exponent)\n";
 
    calls_["#print"] =
        "\n#print (statement):\n"
        "  Prints a statement that can contain MADARA KaRL variables.\n"
        "  Variables are expanding to include their values where applicable.\n"
        "  For instance, 'var{.id}' would result in printing 'var0' if .id\n"
        "  was set to 0. The same statement would print 'variable' if .id\n"
        "  was set to 'iable'.\n";
 
    calls_["#print_system_calls"] =
        "\n#print_system_calls () or #print_system_call (system_call):\n"
        "  Prints help for all system calls or a specific system call.\n";
 
    calls_["#rand_double"] =
        "\n#rand_double (floor = 0.0, ceiling = 1.0, update_srand = true):\n"
        "  Generates a random double from a uniform distribution.\n";
 
    calls_["#rand_int"] =
        "\n#rand_int (floor = 0, ceiling = RAND_MAX, update_srand = true):\n"
        "  Generates a random integer from a uniform distribution.\n";
 
    calls_["#read_file"] =
        "\n#read_file (filename) or #read_file (filename, type):\n"
        "  Reads a file and returns its contents. Default is to determine\n"
        "  file type by filname extension. Explicit type can be a string\n"
        "  or an integer of the following values:\n"
        "    'xml' = 16\n"
        "    'text' = 32\n"
        "    'jpeg' = 256\n";
 
    calls_["#set_clock"] =
        "\n#set_clock (value) or #set_clock (variable, value):\n"
        "  Sets the system clock or a variable clock. The value should be\n"
        "  a non-zero integer (Lamport clock) and is used to determine which\n"
        "  variable values are rejected at the transport layer. Returns the\n"
        "  new clock value.\n";
 
    calls_["#set_fixed"] =
        "\n#set_fixed () or #fixed ():\n"
        "  Sets the output format for doubles to fixed format (std::fixed).\n";
 
    calls_["#set_precision"] =
        "\n#set_precision (value) or #precision (value):\n"
        "  Sets the precision that is used to convert doubles to strings.\n"
        "  This is a fixed precision (e.g., 5 for pi would be 3.14159).\n"
        "  Negative value resets to default precision.\n";
 
    calls_["#set_scientific"] =
        "\n#set_scientific () or #scientific ():\n"
        "  Sets the output format for doubles to scientific format\n"
        "  (std::scientific).\n";
 
    calls_["#sin"] = "\n#sin (var):\n"
                     "  Returns the sine of a term (radians)\n";
 
    calls_["#size"] = "\n#size (value):\n"
                      "  Returns the size of the variable or value.\n";
 
    calls_["#sleep"] =
        "\n#sleep (double time_to_sleep in s):\n"
        "  Sleeps for at least the specified time and returns time\n"
        "  spent sleeping in seconds.\n";
 
    calls_["#sqrt"] = "\n#sqrt (value):\n"
                      "  Returns the square root of a value\n";
 
    calls_["#tan"] = "\n#tan (value):\n"
                     "  Returns the tangent of a term (radians)\n";
 
    calls_["#to_buffer"] = "\n#to_buffer (value) or #buffer (value):\n"
                           "  Converts the value to an unsigned char array.\n";
 
    calls_["#to_double"] = "\n#to_double (value) or #double (value):\n"
                           "  Converts the value to a double.\n";
 
    calls_["#to_doubles"] = "\n#to_doubles (value) or #doubles (value):\n"
                            "  Converts the value to an array of doubles.\n";
 
    calls_["#to_host_dirs"] =
        "\n#to_host_dirs (directory):\n"
        "  Returns the host appropriate directory structure, e.g.,.\n"
        "  files/file.txt to files\file.txt on Windows.\n";
 
    calls_["#to_integer"] = "\n#to_integer (value) or #integer (value):\n"
                            "  Converts the value to an integer.\n";
 
    calls_["#to_integers"] = "\n#to_integers (value) or #integers (value):\n"
                             "  Converts the value to an array of integers.\n";
 
    calls_["#to_string"] =
        "\n#to_string (value, delimiter) or #string (value, delimiter):\n"
        "  Converts the value to an ASCII string. Delimiter is an optional\n"
        "  string sequence that separates elements of an integer or double"
        " array.\n";
 
    calls_["#type"] = "\n#type (value):\n"
                      "  Returns the integer type of the variable or value.\n"
                      "  Supported types are:\n"
                      "    UNINITIALIZED = 0\n"
                      "    INTEGER = 1\n"
                      "    STRING = 2\n"
                      "    DOUBLE = 4\n"
                      "    UNKNOWN_FILE_TYPE = 8\n"
                      "    XML = 16\n"
                      "    TEXT_FILE = 32\n"
                      "    INTEGER_ARRAY = 64\n"
                      "    DOUBLE_ARRAY = 128\n"
                      "    IMAGE_JPEG = 256\n";
 
    calls_["#write_file"] =
        "\n#write_file (filename, value):\n"
        "  Writes the value to a file. Supports all MADARA types.\n"
        "  @see #type.\n";
  }
 
  return result;
}
 
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallPrintSystemCalls::evaluate(
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  knowledge::KnowledgeRecord return_value;
 
  if (nodes_.size() == 1)
  {
    madara_logger_ptr_log(logger_, logger::LOG_MINOR,
        "madara::expression::SystemCallPrintSystemCalls: "
        "System call print_system_calls is printing help\n");
 
    context_.print(calls_[nodes_[0]->evaluate(settings).to_string()], 0);
 
    return madara::knowledge::KnowledgeRecord(1);
  }
  else if (nodes_.size() == 0)
  {
    madara_logger_ptr_log(logger_, logger::LOG_MINOR,
        "madara::expression::SystemCallPrintSystemCalls: "
        "System call print_system_calls is printing help\n");
 
    for (SystemCallsHelp::const_iterator i = calls_.begin(); i != calls_.end();
         ++i)
    {
      if (i->first != "#delete_var" && i->first != "#eval" &&
          i->first != "#expand" && i->first != "#expand_env")
        context_.print(i->second, 0);
    }
  }
  else
  {
    madara_logger_ptr_log(logger_, logger::LOG_ERROR,
        "madara::expression::SystemCallPrintSystemCalls: "
        "KARL RUNTIME ERROR:"
        "System call print_system_calls takes either 0"
        " or 1 arguments\n");
 
    throw exceptions::KarlException(
        "madara::expression::SystemCallPrintSystemCalls: "
        "KARL RUNTIME ERROR: "
        "System call print_system_calls takes either 0"
        " or 1 arguments\n");
  }
 
  return return_value;
}
 
// accept a visitor
void madara::expression::SystemCallPrintSystemCalls::accept(
    madara::expression::Visitor& visitor) const
{
  visitor.visit(*this);
}
 
#endif  // _MADARA_NO_KARL_