insertion implicitList in callExp/cellExp fixed.
[scilab.git] / scilab / modules / ast / src / cpp / ast / expHistory.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014 - Scilab Enterprises - Cedric Delamarre
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-en.txt
10  *
11  */
12
13 #include "expHistory.hxx"
14 #include "types_tools.hxx"
15 #include "types.hxx"
16 #include "context.hxx"
17
18 /**
19 ** Constructor & Destructor (public)
20 */
21
22 ExpHistory::ExpHistory() : m_pArgs(NULL), m_piArgsDimsArray(NULL), m_pExp(NULL), m_pParent(NULL), m_pITCurrent(NULL), m_bReinsertMe(false), m_bCellExp(false), m_iArgsDims(0), m_iWhere(-1), m_iLevel(0), m_pArgsOwner(false), m_pExpOwner(false), m_bDeleteCurrent(false)
23 {
24 }
25
26
27 ExpHistory::ExpHistory(ExpHistory* _pEH, ast::SimpleVar* _pExp) : m_pArgs(NULL), m_piArgsDimsArray(NULL), m_pExp(_pExp), m_pParent(_pEH), m_pITCurrent(NULL), m_bReinsertMe(false), m_bCellExp(false), m_iArgsDims(0), m_iWhere(-1), m_iLevel(0), m_pArgsOwner(false), m_pExpOwner(false), m_bDeleteCurrent(false)
28 {
29 }
30
31 ExpHistory::ExpHistory(ExpHistory* _pParent, types::typed_list* _pArgs) : m_pArgs(_pArgs), m_piArgsDimsArray(NULL), m_pExp(NULL), m_pParent(_pParent), m_pITCurrent(NULL), m_bReinsertMe(false), m_bCellExp(false), m_iArgsDims(0), m_iWhere(-1), m_iLevel(0), m_pArgsOwner(false), m_pExpOwner(false), m_bDeleteCurrent(false)
32 {
33 }
34
35 ExpHistory::ExpHistory(ExpHistory* _pParent, ast::SimpleVar* _pExp, types::typed_list* _pArgs, int _iLevel,  bool _bCellExp, types::InternalType* _pITCurrent) :
36     m_pArgs(_pArgs),
37     m_piArgsDimsArray(NULL),
38     m_pExp(_pExp),
39     m_pParent(_pParent),
40     m_pITCurrent(_pITCurrent),
41     m_bReinsertMe(false),
42     m_bCellExp(_bCellExp),
43     m_iArgsDims(0),
44     m_iWhere(-1),
45     m_iLevel(_iLevel),
46     m_pArgsOwner(false),
47     m_pExpOwner(false),
48     m_bDeleteCurrent(false)
49 {
50 }
51
52 ExpHistory::~ExpHistory()
53 {
54     if (m_pExpOwner)
55     {
56         delete m_pExp;
57     }
58
59     if (m_piArgsDimsArray)
60     {
61         delete[] m_piArgsDimsArray;
62     }
63
64     if (m_pArgs && m_pArgsOwner)
65     {
66         types::typed_list::iterator iter = m_pArgs->begin();
67         for (; iter != m_pArgs->end(); ++iter)
68         {
69             (*iter)->killMe();
70         }
71
72         delete m_pArgs;
73         m_pArgs = NULL;
74     }
75
76     if (m_pITCurrent && m_bDeleteCurrent)
77     {
78         m_pITCurrent->killMe();
79     }
80 }
81
82 /**
83 ** Accessor (public)
84 */
85
86 void ExpHistory::setExp(ast::SimpleVar* _pExp)
87 {
88     m_pExp = _pExp;
89 }
90
91 ast::SimpleVar* ExpHistory::getExp()
92 {
93     return m_pExp;
94 }
95
96 std::wstring ExpHistory::getExpAsString()
97 {
98     std::wstring wcsExp = L"";
99     if (m_pExp)
100     {
101         wcsExp = m_pExp->getSymbol().getName();
102     }
103
104     return wcsExp;
105 }
106
107 void ExpHistory::setArgs(types::typed_list* _pArgs)
108 {
109     if (m_pArgs && m_pArgsOwner)
110     {
111         delete m_pArgs;
112     }
113     m_pArgs = _pArgs;
114     m_pArgsOwner = true;
115 }
116
117 void ExpHistory::setArgsOwner(bool owner)
118 {
119     m_pArgsOwner = owner;
120 }
121
122 void ExpHistory::setExpOwner(bool owner)
123 {
124     m_pExpOwner = owner;
125 }
126
127 void ExpHistory::setDeleteCurrent(bool bDelete)
128 {
129     m_bDeleteCurrent = bDelete;
130 }
131
132 void ExpHistory::computeArgs()
133 {
134     if (m_pArgs)
135     {
136         m_iArgsDims = (int)m_pArgs->size();
137
138         // compute indexes
139         m_piArgsDimsArray  = new int[m_iArgsDims];
140
141         types::typed_list* pNewArgs = new types::typed_list();
142         types::checkIndexesArguments(m_pITCurrent, m_pArgs, pNewArgs, m_piArgsDimsArray, NULL);
143
144         // Delete pArgs only if i'm the owner
145         // else it will be deleted by the expHistory
146         // which are the flag m_pArgsOwner = true
147         if (m_pArgsOwner)
148         {
149             delete m_pArgs;
150         }
151
152         m_pArgs = pNewArgs;
153         m_pArgsOwner = true;
154
155         int* piDimsArray = m_pITCurrent->getAs<types::GenericType>()->getDimsArray();
156         if (m_iArgsDims == 1)
157         {
158             if (m_pITCurrent->getAs<types::GenericType>()->getDims() == 2)
159             {
160                 if (piDimsArray[1] == 1 ||
161                         (piDimsArray[0] == 0 && piDimsArray[1] == 0))
162                 {
163                     int iTemp = m_piArgsDimsArray[0];
164                     delete[] m_piArgsDimsArray;
165                     m_piArgsDimsArray = new int[2];
166                     m_iArgsDims = 2;
167                     m_piArgsDimsArray[0] = iTemp;
168                     m_piArgsDimsArray[1] = 1;
169                 }
170                 else if (piDimsArray[0] == 1)
171                 {
172                     int iTemp = m_piArgsDimsArray[0];
173                     delete[] m_piArgsDimsArray;
174                     m_piArgsDimsArray = new int[2];
175                     m_iArgsDims = 2;
176                     m_piArgsDimsArray[0] = 1;
177                     m_piArgsDimsArray[1] = iTemp;
178                 }
179             }
180         }
181         else
182         {
183             const int size = std::min(m_iArgsDims, m_pITCurrent->getAs<types::GenericType>()->getDims());
184             for (int i = 0; i < size; i++)
185             {
186                 if (piDimsArray[i] > m_piArgsDimsArray[i])
187                 {
188                     m_piArgsDimsArray[i] = piDimsArray[i];
189                 }
190             }
191         }
192     }
193 }
194
195 types::typed_list* ExpHistory::getArgs()
196 {
197     return m_pArgs;
198 }
199
200 int ExpHistory::getSizeFromArgs()
201 {
202     int iSizeFromArgs = 0;
203
204     if (m_pArgs)
205     {
206         int size;
207         iSizeFromArgs = 1;
208         if (m_piArgsDimsArray == NULL)
209         {
210             computeArgs();
211         }
212
213         size = (int)m_pArgs->size();
214         for (int i = 0; i < size; i++)
215         {
216             iSizeFromArgs *= m_piArgsDimsArray[i];
217         }
218     }
219
220     return iSizeFromArgs;
221 }
222
223 int* ExpHistory::getArgsDimsArray()
224 {
225     if (m_pArgs)
226     {
227         if (m_piArgsDimsArray == NULL)
228         {
229             computeArgs();
230         }
231     }
232
233     return m_piArgsDimsArray;
234 }
235
236 int ExpHistory::getArgsDims()
237 {
238     if (m_pArgs)
239     {
240         if (m_piArgsDimsArray == NULL)
241         {
242             computeArgs();
243         }
244     }
245
246     return m_iArgsDims;
247 }
248
249 bool ExpHistory::needResize()
250 {
251     if (m_pArgs)
252     {
253         int iDims = m_pITCurrent->getAs<types::GenericType>()->getDims();
254
255         if (m_piArgsDimsArray == NULL)
256         {
257             computeArgs();
258         }
259
260         if (m_iArgsDims == 1)
261         {
262             int iSize = m_pITCurrent->getAs<types::GenericType>()->getSize();
263             if (iSize < m_piArgsDimsArray[0])
264             {
265                 return true;
266             }
267         }
268         else
269         {
270             if (iDims < m_iArgsDims)
271             {
272                 return true;
273             }
274
275             int* piDimsArray = m_pITCurrent->getAs<types::GenericType>()->getDimsArray();
276             for (int i = 0; i < m_iArgsDims; i++)
277             {
278                 if (piDimsArray[i] < m_piArgsDimsArray[i])
279                 {
280                     return true;
281                 }
282             }
283         }
284     }
285
286     return false;
287 }
288
289 bool ExpHistory::setCurrent(types::InternalType* _pITCurrent)
290 {
291     if (m_pITCurrent == _pITCurrent)
292     {
293         return false;
294     }
295
296     if (m_pITCurrent)
297     {
298         m_pITCurrent->killMe();
299     }
300
301     m_pITCurrent = _pITCurrent;
302
303     // if m_pITCurrent is new, we have to reinsert it in this parent
304     // even if it is an handle (see comment about handle in setReinsertion)
305     m_bReinsertMe = true;
306
307     return true;
308 }
309
310 types::InternalType* ExpHistory::getCurrent()
311 {
312     return m_pITCurrent;
313 }
314
315 ExpHistory* ExpHistory::getParent()
316 {
317     return m_pParent;
318 }
319
320 void ExpHistory::setReinsertion()
321 {
322     // special case for handle, we have not to reinsert
323     // the handle in this parent after insertion of something
324     // in handle by overload.
325     if (m_pITCurrent != NULL && m_pITCurrent->isHandle() == false)
326     {
327         m_bReinsertMe = true;
328     }
329 }
330
331 void ExpHistory::resetReinsertion()
332 {
333     m_bReinsertMe = false;
334 }
335
336 bool ExpHistory::reinsertMe()
337 {
338     return m_bReinsertMe;
339 }
340
341 int ExpHistory::getWhereReinsert()
342 {
343     return m_iWhere;
344 }
345
346 void ExpHistory::setWhereReinsert(int _iWhere)
347 {
348     m_iWhere = _iWhere;
349 }
350
351 int ExpHistory::getLevel()
352 {
353     return m_iLevel;
354 }
355
356 void ExpHistory::setLevel(int _iLevel)
357 {
358     m_iLevel = _iLevel;
359 }
360
361 void ExpHistory::setCellExp()
362 {
363     m_bCellExp = true;
364 }
365
366 bool ExpHistory::isCellExp()
367 {
368     return m_bCellExp;
369 }