Use a stack to manage "where" location
[scilab.git] / scilab / modules / ast / includes / types / internal.hxx
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *  Copyright (C) 2010-2010 - DIGITEO - Bruno JOFRET
5 *
6 *  This file must be used under the terms of the CeCILL.
7 *  This source file is licensed as described in the file COPYING, which
8 *  you should have received as part of this distribution.  The terms
9 *  are also available at
10 *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11 *
12 */
13
14
15 #ifndef __INTERNAL_HXX__
16 #define __INTERNAL_HXX__
17
18 #include <vector>
19 #include <map>
20 #include <iostream>
21 #include <string.h>
22
23 extern "C"
24 {
25 #include "dynlib_ast.h"
26 #include "configvariable_interface.h"
27 }
28
29 #include "exp.hxx" // for invoke
30 #include "visitor.hxx" // for invoke
31 #include "callexp.hxx"
32 #include "localization.hxx"
33 #include "scilabexception.hxx"
34
35
36 #define bsiz 4096
37
38 //#define _SCILAB_DEBUGREF_
39 #ifdef _SCILAB_DEBUGREF_
40 //#define _SCILAB_DEBUGREF_WITHOUT_START_END
41 #define DecreaseRef() _decreaseref(__FILE__, __LINE__)
42 #define IncreaseRef() _increaseref(__FILE__, __LINE__)
43 #define killMe() _killme(__FILE__, __LINE__)
44 #endif
45
46 namespace types
47 {
48 /*
49 ** List of types
50 */
51 class InternalType;
52 typedef std::vector<InternalType *> typed_list;
53 typedef std::vector<std::pair<std::wstring, InternalType *> > optional_list;
54
55 class EXTERN_AST InternalType
56 {
57 public :
58     enum ScilabType
59     {
60         ScilabNull, //no type, no data, nothing !
61         /* Internal Type */
62         ScilabInternal,
63         /* Generic Types */
64         ScilabGeneric,
65         ScilabInt8,
66         ScilabUInt8,
67         ScilabInt16,
68         ScilabUInt16,
69         ScilabInt32,
70         ScilabUInt32,
71         ScilabInt64,
72         ScilabUInt64,
73         ScilabString,
74         ScilabDouble,
75         ScilabBool,
76         ScilabFloat,
77         ScilabPolynom,
78         ScilabSinglePolynom,
79         /* Callable */
80         ScilabFunction,
81         ScilabMacro,
82         ScilabMacroFile,
83         /* Implicit List */
84         ScilabImplicitList,
85         /* Container */
86         ScilabContainer,
87         ScilabList,
88         ScilabTList,
89         ScilabMList,
90         ScilabSingleStruct,
91         ScilabStruct,
92         ScilabCell,
93         /* User */
94         ScilabUserType,
95         /*For list operation*/
96         ScilabListOperation, //parent type
97         ScilabListInsertOperation,
98         ScilabListDeleteOperation,
99         ScilabListUndefinedOperation,
100         ScilabFile,
101         ScilabColon,
102         ScilabDollar,
103         ScilabThreadId,
104         ScilabSparse,
105         ScilabSparseBool,
106         ScilabHandle,
107         ScilabVoid,
108         ScilabLibrary
109     };
110
111     enum ScilabId
112     {
113         IdNull, //no type, no data, nothing !
114         /* Internal Type */
115         IdInternal,
116         /* Generic Types */
117         IdGeneric,
118         IdEmpty,
119         IdIdentity,
120         IdIdentityComplex,
121         IdInt8,
122         IdScalarInt8,
123         IdUInt8,
124         IdScalarUInt8,
125         IdInt16,
126         IdScalarInt16,
127         IdUInt16,
128         IdScalarUInt16,
129         IdInt32,
130         IdScalarInt32,
131         IdUInt32,
132         IdScalarUInt32,
133         IdInt64,
134         IdScalarInt64,
135         IdUInt64,
136         IdScalarUInt64,
137         IdString,
138         IdScalarString,
139         IdDouble,
140         IdDoubleComplex,
141         IdScalarDouble,
142         IdScalarDoubleComplex,
143         IdBool,
144         IdScalarBool,
145         IdPolynom,
146         IdScalarPolynomComplex,
147         IdScalarPolynom,
148         IdPolynomComplex,
149         IdSinglePolynom,
150         /* Callable */
151         IdFunction,
152         IdMacro,
153         IdMacroFile,
154         /* Implicit List */
155         IdImplicitList,
156         /* Container */
157         IdContainer,
158         IdList,
159         IdTList,
160         IdMList,
161         IdSingleStruct,
162         IdStruct,
163         IdCell,
164         /* User */
165         IdUserType,
166         /*For list operation*/
167         IdListOperation, //parent type
168         IdListInsertOperation,
169         IdListDeleteOperation,
170         IdListUndefinedOperation,
171         IdFile,
172         IdColon,
173         IdDollar,
174         IdThreadId,
175         IdSparse,
176         IdSparseComplex,
177         IdSparseBool,
178         IdHandle,
179         IdScalarHandle,
180         IdVoid,
181         IdLibrary,
182         IdLast //msut always be the last value
183     };
184
185 protected :
186     InternalType() : m_iRef(0), m_bAllowDelete(true), m_bPrintFromStart(true), m_iSavePrintState(0), m_iRows1PrintState(0), m_iCols1PrintState(0), m_iRows2PrintState(0), m_iCols2PrintState(0), bKillMe(false)
187     {
188 #ifdef _SCILAB_DEBUGREF_
189 #if defined(_SCILAB_DEBUGREF_WITHOUT_START_END)
190         if (getStartProcessing() == 0 && getEndProcessing() == 0)
191 #endif
192         {
193             std::cout << "new_IT " << m_iRef << " " << (void*)this << std::endl;
194         }
195 #endif
196     }
197
198 public :
199     virtual                         ~InternalType()
200     {
201 #ifdef _SCILAB_DEBUGREF_
202 #if defined(_SCILAB_DEBUGREF_WITHOUT_START_END)
203         if (getStartProcessing() == 0 && getEndProcessing() == 0 && bKillMe == false)
204 #endif
205         {
206             std::cout << "delete_IT " << m_iRef << " " << (void*)this << std::endl;
207         }
208 #endif
209     }
210     virtual void                    whoAmI(void)
211     {
212         std::cout << "types::Internal";
213     }
214
215     virtual bool                    isAssignable(void)
216     {
217         return false;
218     }
219     virtual ScilabType              getType(void) = 0 ; //{ return ScilabInternal; }
220     virtual ScilabId                getId(void) = 0 ; //{ return ScilabInternal; }
221
222     virtual bool                    hasToString()
223     {
224         return true;
225     }
226     virtual bool                    toString(std::wostringstream& ostr) = 0;
227
228     virtual std::wstring            toStringInLine()
229     {
230         return getTypeStr();
231     }
232     virtual InternalType*           clone(void) = 0;
233     virtual ast::Exp*               getExp(const Location& /*loc*/)
234     {
235         return NULL;
236     }
237
238 #ifdef _SCILAB_DEBUGREF_
239     inline void _killme(const char * f, int l)
240     {
241 #if defined(_SCILAB_DEBUGREF_WITHOUT_START_END)
242         if (getStartProcessing() == 0 && getEndProcessing() == 0)
243 #endif
244         {
245             std::cout << "killme " << m_iRef << " " << (void*)this << " in " << f << " at line " << l << std::endl;
246         }
247
248         if (isDeletable())
249         {
250             bKillMe = true;
251             delete this;
252         }
253     }
254
255     inline void _increaseref(const char * f, int l)
256     {
257         m_iRef++;
258 #if defined(_SCILAB_DEBUGREF_WITHOUT_START_END)
259         if (getStartProcessing() == 0 && getEndProcessing() == 0)
260 #endif
261         {
262             std::cout << "incref " << m_iRef << " " << (void*)this << " in " << f << " at line " << l << std::endl;
263         }
264     }
265
266     inline void _decreaseref(const char * f, int l)
267     {
268         if (m_iRef > 0)
269         {
270             m_iRef--;
271         }
272
273 #if defined(_SCILAB_DEBUGREF_WITHOUT_START_END)
274         if (getStartProcessing() == 0 && getEndProcessing() == 0)
275 #endif
276         {
277             std::cout << "decref " << m_iRef << " " << (void*)this << " in " << f << " at line " << l << std::endl;
278         }
279     }
280 #else
281
282     inline void killMe()
283     {
284         if (isDeletable())
285         {
286             delete this;
287         }
288     }
289
290     inline void IncreaseRef()
291     {
292         m_iRef++;
293     }
294
295     inline void DecreaseRef()
296     {
297         if (m_iRef > 0)
298         {
299             m_iRef--;
300         }
301     }
302 #endif
303
304     inline bool isDeletable()
305     {
306         return m_iRef == 0;
307     }
308
309     inline bool isRef(int _iRef = 0)
310     {
311         return m_iRef > _iRef;
312     }
313
314     inline int getRef()
315     {
316         return m_iRef;
317     }
318
319     virtual bool isTrue()
320     {
321         return false;
322     }
323
324     virtual bool neg(InternalType *& /*out*/)
325     {
326         return false;
327     }
328
329     virtual bool transpose(InternalType *& /*out*/)
330     {
331         return false;
332     }
333
334     virtual bool adjoint(InternalType *& out)
335     {
336         return transpose(out);
337     }
338
339     virtual bool isFieldExtractionOverloadable() const
340     {
341         return false;
342     }
343
344     virtual bool invoke(typed_list & /*in*/, optional_list & /*opt*/, int /*_iRetCount*/, typed_list & /*out*/, ast::ConstVisitor & /*execFunc*/, const ast::Exp & /*e*/)
345     {
346         return false;
347     }
348
349     virtual bool isInvokable() const
350     {
351         return false;
352     }
353
354     virtual bool hasInvokeOption() const
355     {
356         return false;
357     }
358
359     virtual int getInvokeNbIn()
360     {
361         return -1;
362     }
363
364     virtual int getInvokeNbOut()
365     {
366         return -1;
367     }
368
369     /* return type as string ( double, int, cell, list, ... )*/
370     virtual std::wstring            getTypeStr() = 0;
371     /* return type as short string ( s, i, ce, l, ... )*/
372     virtual std::wstring            getShortTypeStr() = 0;
373
374     virtual bool                    operator==(const InternalType& it)
375     {
376         return (getType() == (const_cast<InternalType *>(&it))->getType());
377     }
378     virtual bool                    operator!=(const InternalType& it)
379     {
380         return !(*this == it);
381     }
382
383     /**
384     ** GenericType
385     ** \{
386     */
387
388     template <class T>
389     inline T*                              getAs(void)
390     {
391         return static_cast<T*>(this);
392     }
393
394     virtual bool                    isGenericType(void)
395     {
396         return false;
397     }
398     virtual bool                    isArrayOf(void)
399     {
400         return false;
401     }
402     virtual bool                    isString(void)
403     {
404         return false;
405     }
406     virtual bool                    isDouble(void)
407     {
408         return false;
409     }
410     virtual bool                    isSparse(void)
411     {
412         return false;
413     }
414     virtual bool                    isSparseBool(void)
415     {
416         return false;
417     }
418     virtual bool                    isFloat(void)
419     {
420         return false;
421     }
422     virtual bool                    isInt(void)
423     {
424         return false;
425     }
426     virtual bool                    isInt8(void)
427     {
428         return false;
429     }
430     virtual bool                    isUInt8(void)
431     {
432         return false;
433     }
434     virtual bool                    isInt16(void)
435     {
436         return false;
437     }
438     virtual bool                    isUInt16(void)
439     {
440         return false;
441     }
442     virtual bool                    isInt32(void)
443     {
444         return false;
445     }
446     virtual bool                    isUInt32(void)
447     {
448         return false;
449     }
450     virtual bool                    isInt64(void)
451     {
452         return false;
453     }
454     virtual bool                    isUInt64(void)
455     {
456         return false;
457     }
458     virtual bool                    isBool(void)
459     {
460         return false;
461     }
462     virtual bool                    isPoly(void)
463     {
464         return false;
465     }
466     virtual bool                    isSinglePoly(void)
467     {
468         return false;
469     }
470     virtual bool                    isCallable(void)
471     {
472         return false;
473     }
474     virtual bool                    isFunction(void)
475     {
476         return false;
477     }
478     virtual bool                    isMacro(void)
479     {
480         return false;
481     }
482     virtual bool                    isMacroFile(void)
483     {
484         return false;
485     }
486     virtual bool                    isContainer(void)
487     {
488         return false;
489     }
490     virtual bool                    isList(void)
491     {
492         return false;
493     }
494     virtual bool                    isStruct(void)
495     {
496         return false;
497     }
498     virtual bool                    isSingleStruct(void)
499     {
500         return false;
501     }
502     virtual bool                    isCell(void)
503     {
504         return false;
505     }
506     virtual bool                    isTList(void)
507     {
508         return false;
509     }
510     virtual bool                    isMList(void)
511     {
512         return false;
513     }
514     virtual bool                    isImplicitList(void)
515     {
516         return false;
517     }
518     virtual bool                    isColon(void)
519     {
520         return false;
521     }
522     virtual bool                    isDollar(void)
523     {
524         return false;
525     }
526     virtual bool                    isFile(void)
527     {
528         return false;
529     }
530     virtual bool                    isHandle(void)
531     {
532         return false;
533     }
534     virtual bool                    isSingleHandle(void)
535     {
536         return false;
537     }
538     virtual bool                    isThreadId(void)
539     {
540         return false;
541     }
542     virtual bool                    isListOperation(void)
543     {
544         return false;
545     }
546     virtual bool                    isListDelete(void)
547     {
548         return false;
549     }
550     virtual bool                    isListInsert(void)
551     {
552         return false;
553     }
554     virtual bool                    isListUndefined(void)
555     {
556         return false;
557     }
558     virtual bool                    isPointer(void)
559     {
560         return false;
561     }
562     virtual bool                    isLibrary(void)
563     {
564         return false;
565     }
566     virtual bool                    isUserType(void)
567     {
568         return false;
569     }
570
571     void clearPrintState()
572     {
573         m_bPrintFromStart = true;
574         m_iSavePrintState = 0;
575         m_iRows1PrintState = 0;
576         m_iCols1PrintState = 0;
577         m_iRows2PrintState = 0;
578         m_iCols2PrintState = 0;
579     }
580
581
582 protected :
583     int                             m_iRef;
584     //use to know if we can delete this variables or if it's link to a scilab variable.
585     bool                            m_bAllowDelete;
586
587     /*variables to manage print taking care of lines*/
588     bool                    m_bPrintFromStart;
589     int                     m_iSavePrintState;
590     int                     m_iRows1PrintState;
591     int                     m_iCols1PrintState;
592     int                     m_iRows2PrintState;
593     int                     m_iCols2PrintState;
594
595     bool bKillMe;
596
597 };
598
599 }
600
601 #ifdef _SCILAB_DEBUGREF_
602 #undef _SCILAB_DEBUGREF_
603 #endif
604
605 #endif /* !__INTERNAL_HXX__ */