scilab/modules/string/sci_gateway/cpp/sci_stripblanks.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2010 - DIGITEO - Allan CORNET
   4 *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  * Copyright (C) 2017 Siddhartha Gairola
   7  *
   8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
  10  * This file was originally licensed under the terms of the CeCILL v2.1,
  11  * and continues to be available under such terms.
  12  * For more information, see the COPYING file which you should have received
  13  * along with this program.
  14 *
  15 */
  16 /*--------------------------------------------------------------------------*/
  17 #include "string_gw.hxx"
  18 #include "function.hxx"
  19 #include "context.hxx"
  20 #include "types.hxx"
  21 #include "bool.hxx"
  22 #include "double.hxx"
  23 #include "stripblanks.hxx"
  24 /*--------------------------------------------------------------------------*/
  25 extern "C"
  26 {
  27 #include "localization.h"
  28 #include "Scierror.h"
  29 }
  30 /*--------------------------------------------------------------------------*/
  31 types::Function::ReturnValue sci_stripblanks(types::typed_list &in, int _iRetCount, types::typed_list &out)
  32 {
  33 #define FUNCNAME "stripblanks"
  34     bool bRemoveTab = false;
  35     double  flag = 0;
  36
  37     // check input parameters
  38     if (in.size() < 1 || in.size() > 3)
  39     {
  40         Scierror(999, _("%s: Wrong number of input arguments: %d to %d expected.\n"), FUNCNAME, 1, 3);
  41         return types::Function::Error;
  42     }
  43
  44     // check output parameters
  45     if (_iRetCount != 1 && _iRetCount != -1)
  46     {
  47         Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), FUNCNAME, 1);
  48         return types::Function::Error;
  49     }
  50
  51     if (in.size() > 1)
  52     {
  53         if (in[1]->isBool() == false || in[1]->getAs<types::Bool>()->isScalar() == false)
  54         {
  55             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), FUNCNAME, 2);
  56             return types::Function::Error;
  57         }
  58
  59         if (in[1]->getAs<types::Bool>()->get()[0] == 1)
  60         {
  61             bRemoveTab = true;
  62         }
  63     }
  64
  65     if (in.size() == 3)
  66     {
  67         if (in[2]->isDouble() == false || in[2]->getAs<types::Double>()->isScalar() == false)
  68         {
  69
  70             Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), FUNCNAME, 2);
  71             return types::Function::Error;
  72
  73         }
  74
  75         flag = in[2]->getAs<types::Double>()->get()[0];
  76
  77         if (floor(flag) != flag || (flag != 0.0 && flag != 1.0 && flag != -1.0))
  78         {
  79
  80             Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), FUNCNAME, 3, "-1, 0, 1");
  81             return types::Function::Error;
  82         }
  83
  84     }
  85
  86     switch (in[0]->getType())
  87     {
  88         case types::InternalType::ScilabString:
  89         {
  90             types::String *pS = stripblanks(in[0]->getAs<types::String>(), bRemoveTab, static_cast<int>(flag));
  91             if (pS == NULL)
  92             {
  93                 Scierror(999, _("%s : No more memory.\n"), FUNCNAME);
  94                 return types::Function::Error;
  95             }
  96
  97             out.push_back(pS);
  98             break;
  99         }
 100         case types::InternalType::ScilabDouble://manage []
 101         {
 102             if (in[0]->getAs<types::Double>()->getSize() != 0)
 103             {
 104                 Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings or empty matrix expected.\n"), FUNCNAME, 1);
 105                 return types::Function::Error;
 106             }
 107
 108             out.push_back(types::Double::Empty());
 109             break;
 110         }
 111         default:
 112         {
 113             Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings or empty matrix expected.\n"), FUNCNAME, 1);
 114             return types::Function::Error;
 115         }
 116     }
 117
 118     return types::Function::OK;
 119 }
 120 /*--------------------------------------------------------------------------*/