utf: api_scilab 2
[scilab.git] / scilab / modules / api_scilab / src / cpp / api_stack_pointer.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  * Please note that piece of code will be rewrited for the Scilab 6 family
12  * However, the API (profile of the functions in the header files) will be
13  * still available and supported in Scilab 6.
14  */
15
16 #include "gatewaystruct.hxx"
17 #include "pointer.hxx"
18 #include "context.hxx"
19
20 extern "C"
21 {
22 #include "api_scilab.h"
23 #include "api_internal_common.h"
24 #include "localization.h"
25 }
26
27 SciErr getPointer(void* _pvCtx, int* _piAddress, void const** _pvPtr)
28 {
29     SciErr sciErr = sciErrInit();
30     int iType = 0;
31
32     if (_piAddress == NULL)
33     {
34         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "getPointer");
35         return sciErr;
36     }
37
38     sciErr = getVarType(_pvCtx, _piAddress, &iType);
39     if (sciErr.iErr)
40     {
41         addErrorMessage(&sciErr, API_ERROR_GET_POINTER, _("%s: Unable to get argument #%d"), "getPointer", getRhsFromAddress(_pvCtx, _piAddress));
42         return sciErr;
43     }
44
45     if (iType != sci_pointer)
46     {
47         addErrorMessage(&sciErr, API_ERROR_INVALID_TYPE, _("%s: Invalid argument type, %s expected"), "getPointer", _("pointer"));
48         return sciErr;
49     }
50
51     *_pvPtr = ((types::InternalType*)_piAddress)->getAs<types::Pointer>()->get();
52     return sciErr;
53 }
54
55 SciErr createPointer(void* _pvCtx, int _iVar, const void* _pvPtr)
56 {
57     SciErr sciErr = sciErrInit();
58
59     if (_pvCtx == NULL)
60     {
61         addErrorMessage(&sciErr, API_ERROR_INVALID_POINTER, _("%s: Invalid argument address"), "creatPointer");
62         return sciErr;
63     }
64
65     types::GatewayStruct* pStr = (types::GatewayStruct*)_pvCtx;
66     types::InternalType** out = pStr->m_pOut;
67
68     types::Pointer* pP = NULL;
69
70     try
71     {
72         pP = new types::Pointer(_pvPtr);
73         if (pP == NULL)
74         {
75             addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: No more memory to allocate variable"), "createPointer");
76             return sciErr;
77         }
78     }
79     catch (const ast::InternalError& ie)
80     {
81         addErrorMessage(&sciErr, API_ERROR_NO_MORE_MEMORY, _("%s: %s"), "createPointer", ie.GetErrorMessage().c_str());
82         return sciErr;
83     }
84
85     int rhs = _iVar - *getNbInputArgument(_pvCtx);
86     out[rhs - 1] = pP;
87
88     return sciErr;
89 }
90
91 SciErr createNamedPointer(void* _pvCtx, const char* _pstName, const void* _pvPtr)
92 {
93     SciErr sciErr = sciErrInit();
94
95     // check variable name
96     if (checkNamedVarFormat(_pvCtx, _pstName) == 0)
97     {
98         addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Invalid variable name: %s."), "createNamedPointer", _pstName);
99         return sciErr;
100     }
101
102     types::Pointer* pP = new types::Pointer(_pvPtr);
103     symbol::Context* ctx = symbol::Context::getInstance();
104     symbol::Symbol sym = symbol::Symbol(_pstName);
105     if (ctx->isprotected(sym) == false)
106     {
107         ctx->put(sym, pP);
108     }
109     else
110     {
111         delete pP;
112         addErrorMessage(&sciErr, API_ERROR_REDEFINE_PERMANENT_VAR, _("Redefining permanent variable.\n"));
113     }
114
115     return sciErr;
116 }
117
118 SciErr readNamedPointer(void* _pvCtx, const char* _pstName, void const ** _pvPtr)
119 {
120     int* piAddr = NULL;
121     const void *pvPtr = NULL;
122
123     SciErr sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
124     if (sciErr.iErr)
125     {
126         addErrorMessage(&sciErr, API_ERROR_READ_POINTER, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
127         return sciErr;
128     }
129
130     sciErr = getPointer(_pvCtx, piAddr, &pvPtr);
131     if (sciErr.iErr)
132     {
133         addErrorMessage(&sciErr, API_ERROR_READ_POINTER, _("%s: Unable to get variable \"%s\""), "readNamedMatrixOfBoolean", _pstName);
134         return sciErr;
135     }
136
137     *_pvPtr = pvPtr;
138
139     return sciErr;
140 }
141 /*--------------------------------------------------------------------------*/
142 int isPointerType(void* _pvCtx, int* _piAddress)
143 {
144     return checkVarType(_pvCtx, _piAddress, sci_pointer);
145 }
146 /*--------------------------------------------------------------------------*/
147 int isNamedPointerType(void* _pvCtx, const char* _pstName)
148 {
149     return checkNamedVarType(_pvCtx, _pstName, sci_pointer);
150 }
151 /*--------------------------------------------------------------------------*/
152