String: share a common empty string value
[scilab.git] / scilab / modules / string / sci_gateway / cpp / sci_emptystr.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2017 - Scilab Enterprises - Antoine ELIAS
4 *
5 * Copyright (C) 2012 - 2016 - Scilab Enterprises
6 *
7 * This file is hereby licensed under the terms of the GNU GPL v2.0,
8 * pursuant to article 5.3.4 of the CeCILL v.2.1.
9 * This file was originally licensed under the terms of the CeCILL v2.1,
10 * and continues to be available under such terms.
11 * For more information, see the COPYING file which you should have received
12 * along with this program.
13 *
14 */
15 /*--------------------------------------------------------------------------*/
16 #include <string>
17 #include "string_gw.hxx"
18 #include "function.hxx"
19 #include "double.hxx"
20 #include "string.hxx"
21 #include "list.hxx"
22 #include "overload.hxx"
23 /*--------------------------------------------------------------------------*/
24 extern "C"
25 {
26 #include "localization.h"
27 #include "Scierror.h"
28 }
29
30 static const std::string fname("emptystr");
31 /*--------------------------------------------------------------------------*/
32 types::Function::ReturnValue sci_emptystr(types::typed_list &in, int _iRetCount, types::typed_list &out)
33 {
34     types::String* ret = nullptr;
35     int iRhs = static_cast<int>(in.size());
36
37     // check output parameters
38     if (_iRetCount != 1 && _iRetCount != -1)
39     {
40         Scierror(999, _("%s: Wrong number of output arguments: %d expected.\n"), fname.data(), 1);
41         return types::Function::Error;
42     }
43
44     switch (iRhs)
45     {
46         case 1:
47         {
48             if (in[0]->isGenericType())
49             {
50                 types::GenericType* pGT = in[0]->getAs<types::GenericType>();
51                 if (pGT->getSize() == 0)
52                 {
53                     out.push_back(types::Double::Empty());
54                     return types::Function::OK;
55                 }
56
57                 ret = new types::String(pGT->getDims(), pGT->getDimsArray());
58             }
59             else if (in[0]->isList())
60             {
61                 types::List* pL = in[0]->getAs<types::List>();
62                 ret = new types::String(pL->getSize(), 1);
63             }
64             else
65             {
66                 return Overload::generateNameAndCall(L"emptystr", in, _iRetCount, out);
67             }
68
69             break;
70         }
71         case 2:
72         {
73             if (in[0]->isDouble() == false || in[0]->getAs<types::Double>()->isScalar() == false)
74             {
75                 Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of integers expected.\n"), fname.data(), 1);
76                 return types::Function::Error;
77             }
78
79             if (in[1]->isDouble() == false || in[1]->getAs<types::Double>()->isScalar() == false)
80             {
81                 Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of integers expected.\n"), fname.data(), 2);
82                 return types::Function::Error;
83             }
84
85             int row = static_cast<int>(in[0]->getAs<types::Double>()->get()[0]);
86             int col = static_cast<int>(in[1]->getAs<types::Double>()->get()[0]);
87
88             if (row == 0 || col == 0)
89             {
90                 out.push_back(types::Double::Empty());
91                 return types::Function::OK;
92             }
93
94             ret = new types::String(row, col);
95             break;
96         }
97         default:
98         {
99             ret = new types::String(1, 1);
100         }
101     }
102
103     int size = ret->getSize();
104     wchar_t** strs = ret->get();
105     for (int i = 0; i < size; ++i)
106     {
107         strs[i] = types::String::nullValue();
108     }
109
110     out.push_back(ret);
111     return types::Function::OK;
112
113 }