/*--------------------------------------------------------------------------*/
types::Function::ReturnValue sci_scicosDiagramToScilab(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
/*
* to import some files
* scs_m = scicosDiagramToScilab("/path/to/a/file")
* [scs_m1, scs_m2] = scicosDiagramToScilab(["/path/to/a/file", "/path/to/files"])
*
* to export a file
* scicosDiagramToScilab("/path/to/a/file", scs_m)
* scicosDiagramToScilab(["/path/to/a/file", "/path/to/files"], scs_m1, scs_m2)
*/
if (in.size() < 1)
{
Scierror(77, _("%s: Wrong number of input arguments: at least %d expected.\n"), funname, 1);
return types::Function::Error;
}
if (!in[0]->isString())
{
Scierror(77, _("%s: Wrong type for input argument #%d: string expected.\n"), funname, 1);
return types::Function::Error;
}
types::String* files = in[0]->getAs<types::String>();
if (in.size() == 1 && files->getSize() == _iRetCount)
{
// the user asked to import
out.resize(_iRetCount);
for (int i = 0; i < _iRetCount; i++)
{
char* f = wide_string_to_UTF8(files->get(i));
out[i] = importFile(f);
FREE(f);
if (out[i] == nullptr)
{
return types::Function::Error;
}
}
}
else if (in.size() == 1 + static_cast<size_t>(files->getSize()) && _iRetCount <= 1)
{
// the user asked to export
for (int i = 0; i < _iRetCount; i++)
{
if (!in[1 + i]->isUserType())
{
Scierror(77, _("%s: Wrong type for input argument #%d: ""%s"" expected.\n"), funname, "diagram");
return types::Function::Error;
}
}
for (int i = 0; i < _iRetCount; i++)
{
char* f = wide_string_to_UTF8(files->get(i));
bool success = exportFile(1 + i, f, in[1 + i]);
FREE(f);
if (!success)
{
return types::Function::Error;
}
}
}
else
{
// report a comprehensible error message
if (in.size() == 1)
{
Scierror(77, _("%s: Wrong number of output arguments: %d expected.\n"), funname, files->getSize());
}
else if (in.size() == 1 + static_cast<size_t>(files->getSize()))
{
Scierror(77, _("%s: Wrong number of output arguments: %d expected.\n"), funname, 0);
}
else
{
Scierror(77, _("%s: Wrong number of input arguments: %d expected.\n"), funname, 1);
}
return types::Function::Error;
}
return types::Function::OK;
}
/*--------------------------------------------------------------------------*/
types::Function::ReturnValue sci_completion(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
types::String* pStrSomechars = NULL;
char* pcSomechars = NULL;
if (in.size() < 1 || in.size() > 2)
{
Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected."), "completion", 1, 2);
return types::Function::Error;
}
if (_iRetCount > 6)
{
Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected."), "completion", 1, 6);
return types::Function::Error;
}
if (in[0]->isString() == false)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "completion", 1);
return types::Function::Error;
}
pStrSomechars = in[0]->getAs<types::String>();
if (pStrSomechars->isScalar() == false)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), "completion", 1);
return types::Function::Error;
}
pcSomechars = wide_string_to_UTF8(pStrSomechars->get(0));
if (in.size() == 1)
{
if (_iRetCount == 1)
{
out.push_back(doCompletion(pcSomechars, &completion));
}
else
{
out.resize(_iRetCount);
switch (_iRetCount)
{
case 6 :
out[5] = doCompletion(pcSomechars, &completionOnFiles);
case 5 :
out[4] = doCompletion(pcSomechars, &completionOnHandleGraphicsProperties);
case 4 :
out[3] = doCompletion(pcSomechars, &completionOnMacros);
case 3 :
out[2] = doCompletion(pcSomechars, &completionOnVariables);
case 2 :
out[1] = doCompletion(pcSomechars, &completionOnCommandWords);
default :
out[0] = doCompletion(pcSomechars, &completionOnFunctions);
}
}
}
else // if(in.size() == 2)
{
if (_iRetCount != 1)
{
Scierror(78, _("%s: Wrong number of output argument(s): %d expected."), "completion", 1);
return types::Function::Error;
}
if (in[1]->isString() == false)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), "completion", 2);
return types::Function::Error;
}
types::String* pStrDictionary = in[1]->getAs<types::String>();
if (pStrDictionary->isScalar() == false)
{
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), "completion", 2);
return types::Function::Error;
}
wchar_t* wcsDictionary = pStrDictionary->get(0);
if ( wcscmp(wcsDictionary, L"functions") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnFunctions));
}
else if ( wcscmp(wcsDictionary, L"commands") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnCommandWords));
}
else if ( wcscmp(wcsDictionary, L"variables") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnVariables));
}
else if ( wcscmp(wcsDictionary, L"macros") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnMacros));
}
else if ( wcscmp(wcsDictionary, L"graphic_properties") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnHandleGraphicsProperties));
}
else if ( wcscmp(wcsDictionary, L"files") == 0 )
{
out.push_back(doCompletion(pcSomechars, &completionOnFiles));
}
else
{
Scierror(999, _("%s: Wrong value for input argument: '%s', '%s', '%s', '%s', '%s' or '%s' expected.\n"),
"completion", "functions", "commands", "variables", "macros", "graphic_properties", "files");
return types::Function::Error;
}
}
FREE(pcSomechars);
return types::Function::OK;
}
