fix warning in ast module.
[scilab.git] / scilab / modules / ast / includes / ast / deserializervisitor.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2012-2013 - OCAMLPRO INRIA - Fabrice LE FESSANT
4  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
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 #ifndef __DESERIALIZER_HXX__
14 #define __DESERIALIZER_HXX__
15
16 #include <list>
17 #include <all.hxx>
18
19 namespace ast
20 {
21 class DeserializeVisitor
22 {
23 private :
24
25     unsigned char *initial_buf;
26     unsigned char *buf;
27
28
29     unsigned int get_uint8(void)
30     {
31         return *buf++;
32     }
33
34     unsigned int get_uint32(void)
35     {
36         unsigned int c0 = get_uint8();
37         unsigned int c1 = get_uint8();
38         unsigned int c2 = get_uint8();
39         unsigned int c3 = get_uint8();
40         return c0 + ((c1 + ((c2 + (c3 << 8)) << 8 )) << 8 );
41     }
42
43     unsigned long long get_uint64(void)
44     {
45         unsigned long long c0 = get_uint32();
46         unsigned long long c1 = get_uint32();
47         return c0 + (c1 << 32 );
48     }
49
50     int get_int32(void)
51     {
52         return (int)get_uint32();
53     }
54
55     bool get_bool(void)
56     {
57         return get_uint8() == 1;
58     }
59
60     Location get_location(void)
61     {
62         Location loc;
63         loc.first_line = get_uint32();
64         loc.first_column = get_uint32();
65         loc.last_line = get_uint32();
66         loc.last_column = get_uint32();
67         return loc;
68     }
69
70     std::list<Exp*>* get_exps(void)
71     {
72         int nitems = get_uint32();
73         std::list<Exp*> *list = new std::list<Exp*>;
74         for (int i = 0; i < nitems; i++)
75         {
76             Exp* exp = get_exp();
77             list->push_back(exp);
78         }
79         return list;
80     }
81
82     std::list<MatrixLineExp*>* get_MatrixLines(void)
83     {
84         int nitems = get_uint32();
85         std::list<MatrixLineExp*> *list = new std::list<MatrixLineExp*>;
86         for (int i = 0; i < nitems; i++)
87         {
88             Location line_loc = get_location();
89             std::list<Exp*>* columns = get_exps();
90             MatrixLineExp* line = new MatrixLineExp(line_loc, * columns);
91             list->push_back(line);
92         }
93         return list;
94     }
95
96     std::list<Var*>* get_vars(void)
97     {
98         int nitems = get_uint32();
99         std::list<Var*> *list = new  std::list<Var*>;
100         for (int i = 0; i < nitems; i++)
101         {
102             Var* var = static_cast<Var*>(get_exp());
103             list->push_back(var);
104         }
105         return list;
106     }
107
108     OpExp::Oper get_OpExp_Oper(void)
109     {
110         int code = get_uint8();
111         switch (code)
112         {
113             case 1 :
114                 return  OpExp::plus;
115             case 2 :
116                 return  OpExp::minus;
117             case 3 :
118                 return  OpExp::times;
119             case 4 :
120                 return  OpExp::rdivide;
121             case 5 :
122                 return  OpExp::ldivide;
123             case 6 :
124                 return  OpExp::power;
125
126             case 7 :
127                 return  OpExp::dottimes;
128             case 8 :
129                 return  OpExp::dotrdivide;
130             case 9 :
131                 return  OpExp::dotldivide;
132             case 10 :
133                 return  OpExp::dotpower;
134
135             case 11 :
136                 return  OpExp::krontimes;
137             case 12 :
138                 return  OpExp::kronrdivide;
139             case 13 :
140                 return  OpExp::kronldivide;
141
142             case 14 :
143                 return  OpExp::controltimes;
144             case 15 :
145                 return  OpExp::controlrdivide;
146             case 16 :
147                 return  OpExp::controlldivide;
148
149             case 17 :
150                 return  OpExp::eq;
151             case 18 :
152                 return  OpExp::ne;
153             case 19 :
154                 return  OpExp::lt;
155             case 20 :
156                 return  OpExp::le;
157             case 21 :
158                 return  OpExp::gt;
159             case 22 :
160                 return  OpExp::ge;
161
162             case 23 :
163                 return  OpExp::unaryMinus;
164
165             case 24 :
166                 return  OpExp::logicalAnd;
167             case 25 :
168                 return  OpExp::logicalOr;
169             case 26 :
170                 return  OpExp::logicalShortCutAnd;
171             case 27 :
172                 return  OpExp::logicalShortCutOr;
173         }
174         std::cerr << "Unknown get_OpExp_Oper code " << code << std::endl;
175         exit(2);
176     }
177
178     IntExp::Prec get_IntExp_Prec(void)
179     {
180         int code = get_uint8();
181         switch (code)
182         {
183             case 1:
184                 return IntExp::_8_;
185             case 2:
186                 return IntExp::_16_;
187             case 3:
188                 return IntExp::_32_;
189             case 4:
190                 return IntExp::_64_;
191         }
192         std::cerr << "Unknown get_IntExp_Prec code " << code << std::endl;
193         exit(2);
194     }
195
196     TransposeExp::Kind get_TransposeExp_Kind(void)
197     {
198         int code = get_uint8();
199         switch (code)
200         {
201             case 1 :
202                 return TransposeExp::_Conjugate_;
203             case 2 :
204                 return TransposeExp::_NonConjugate_;
205         }
206         std::cerr << "Unknown get_TransposeExp_Kind code " << code << std::endl;
207         exit(2);
208     }
209
210     std::wstring* get_wstring(void)
211     {
212         unsigned int size = get_uint32();
213         wchar_t* ss = (wchar_t*)buf;
214         std::wstring* s = new std::wstring(ss, size / sizeof(wchar_t));
215         buf += size;
216         return s;
217     }
218
219     symbol::Symbol* get_Symbol(void)
220     {
221         std::wstring* s = get_wstring();
222         symbol::Symbol *sym = new symbol::Symbol(*s);
223         delete s;
224         return sym;
225     }
226
227     double get_double(void)
228     {
229         double d = *(double*)buf;
230         buf += 8;
231         return d;
232     }
233
234     VarDec* get_VarDec(Location & vardec_location)
235     {
236         symbol::Symbol *name = get_Symbol();
237         Exp *init = get_exp();
238         VarDec* vardec = new VarDec(vardec_location, *name, *init);
239         return vardec;
240     }
241
242
243     Exp* get_exp(void)
244     {
245         Exp* exp;
246         int code = get_uint8();
247         size_t nodeNumber = get_uint64();
248         Location loc = get_location();
249         bool is_verbose = get_bool();
250         int is_break = get_bool();
251         int is_breakable = get_bool();
252         int is_return = get_bool();
253         int is_returnable = get_bool();
254         int is_continue = get_bool();
255         int is_continuable = get_bool();
256
257
258         switch (code)
259         {
260             case 1:
261             {
262                 std::list<Exp *>* l_body = get_exps();
263                 exp = new SeqExp(loc, *l_body);
264                 break;
265             }
266             case 2:
267             {
268                 std::wstring* s = get_wstring();
269                 exp = new StringExp(loc, *s);
270                 delete s;
271                 break;
272             }
273             case 3:
274             {
275                 std::wstring* s = get_wstring();
276                 exp = new CommentExp(loc, s);
277                 //delete s;
278                 break;
279             }
280             case 6:
281             {
282                 double d = get_double();
283                 exp = new DoubleExp(loc, d);
284                 break;
285             }
286             case 7:
287             {
288                 bool b = get_bool();
289                 exp = new BoolExp(loc, b);
290                 break;
291             }
292             case 8:
293             {
294                 exp = new NilExp(loc);
295                 break;
296             }
297             case 9:
298             {
299                 symbol::Symbol *name = get_Symbol();
300                 exp = new SimpleVar(loc, *name);
301                 break;
302             }
303             case 10:
304             {
305                 exp = new ColonVar(loc);
306                 break;
307             }
308             case 11:
309             {
310                 exp = new DollarVar(loc);
311                 break;
312             }
313             case 12:
314             {
315                 std::list<Var*>* vars = get_vars();
316                 exp = new ArrayListVar(loc, *vars);
317                 break;
318             }
319             case 13:
320             {
321                 Exp *head = get_exp();
322                 Exp *tail = get_exp();
323                 exp = new FieldExp(loc, *head, *tail);
324                 break;
325             }
326             case 14:
327             {
328                 bool has_else = get_bool();
329                 Exp* test = get_exp();
330                 Exp* _then = get_exp();
331                 IfExp* ifexp;
332                 if ( has_else )
333                 {
334                     Exp* _else = get_exp();
335                     ifexp = new IfExp(loc, *test, *_then, *_else);
336                 }
337                 else
338                 {
339                     ifexp = new IfExp(loc, *test, *_then);
340                 }
341                 exp = ifexp;
342                 break;
343             }
344             case 15:
345             {
346                 Location try_location = get_location();
347                 Location catch_location = get_location();
348                 std::list<Exp *>* try_exps = get_exps();
349                 std::list<Exp *>* catch_exps = get_exps();
350                 SeqExp *tryexp = new SeqExp(try_location, *try_exps);
351                 SeqExp *catchexp = new SeqExp(catch_location, *catch_exps);
352                 exp = new TryCatchExp(loc, *tryexp, *catchexp);
353                 break;
354             }
355             case 16:
356             {
357                 Exp* test = get_exp();
358                 Exp* body = get_exp();
359                 exp = new WhileExp(loc, *test, *body);
360                 break;
361             }
362             case 17:
363             {
364                 Location vardec_location = get_location();
365                 VarDec* vardec = get_VarDec(vardec_location);
366                 Exp* body = get_exp();
367                 exp = new ForExp(loc, *vardec, *body);
368                 break;
369             }
370             case 18:
371             {
372                 exp = new BreakExp(loc);
373                 break;
374             }
375             case 19:
376             {
377                 exp = new ContinueExp(loc);
378                 break;
379             }
380             case 20:
381             {
382                 bool is_global = get_bool();
383                 if ( is_global )
384                 {
385                     exp = new ReturnExp(loc);
386                 }
387                 else
388                 {
389                     Exp* returnExp_exp = get_exp();
390                     exp = new ReturnExp(loc, returnExp_exp);
391                 }
392                 break;
393             }
394             case 21:
395             {
396                 bool has_default = get_bool();
397                 SeqExp * default_case = NULL;
398                 if ( has_default )
399                 {
400                     Location default_case_location = get_location();
401                     std::list<Exp *>* default_case_exps = get_exps();
402                     default_case = new SeqExp(default_case_location,
403                                               *default_case_exps);
404                 }
405                 Exp* select = get_exp();
406
407                 int nitems = get_uint32();
408                 std::list<CaseExp*> *cases = new  std::list<CaseExp*>;
409                 for (int i = 0; i < nitems; i++)
410                 {
411
412                     Location case_location = get_location();
413                     Location body_location = get_location();
414                     Exp* test = get_exp();
415                     std::list<Exp *>* body_exps = get_exps();
416                     SeqExp *body = new SeqExp(body_location,  *body_exps);
417
418                     CaseExp* _case = new CaseExp(case_location, *test, *body);
419                     cases->push_back(_case);
420                 }
421
422
423                 if ( has_default )
424                 {
425                     exp = new SelectExp(loc, *select, *cases, *default_case);
426                 }
427                 else
428                 {
429                     exp = new SelectExp(loc, *select, *cases);
430                 }
431                 break;
432             }
433             /* SHOULD NEVER HAPPEN
434             case 22: {
435             exp = new CaseExp(*loc);
436             break;
437             }
438             */
439             case 23:
440             {
441                 std::list<MatrixLineExp *>* lines = get_MatrixLines();
442                 exp = new CellExp(loc, *lines);
443                 break;
444             }
445             case 24:
446             {
447                 std::list<Exp *>* exps = get_exps();
448                 exp = new ArrayListExp(loc, *exps);
449                 break;
450             }
451             case 25:
452             {
453                 std::list<Exp *>* exps = get_exps();
454                 exp = new AssignListExp(loc, *exps);
455                 break;
456             }
457             case 26:
458             {
459                 Exp* notexp = get_exp();
460                 exp = new NotExp(loc, *notexp);
461                 break;
462             }
463             case 27:
464             {
465                 TransposeExp::Kind kind = get_TransposeExp_Kind();
466                 Exp* _exp = get_exp();
467                 exp = new TransposeExp(loc, *_exp, kind);
468                 break;
469             }
470             case 28:
471             {
472                 exp = get_VarDec(loc);
473                 break;
474             }
475             case 29:
476             {
477                 symbol::Symbol* name = get_Symbol();
478                 Location args_loc = get_location();
479                 Location returns_loc = get_location();
480                 Exp* body = get_exp();
481                 std::list <Var*>* args_list = get_vars();
482                 std::list <Var*>* returns_list = get_vars();
483                 ArrayListVar *args = new ArrayListVar(args_loc, *args_list);
484                 ArrayListVar *returns = new ArrayListVar(returns_loc, *returns_list);
485                 exp = new FunctionDec(loc, *name, *args, *returns, *body);
486                 break;
487             }
488             case 30:
489             {
490                 Exp* _start = get_exp();
491                 Exp* _step = get_exp();
492                 Exp* _end = get_exp();
493                 exp = new ListExp(loc, *_start, *_step, *_end);
494                 break;
495             }
496             case 31:
497             {
498                 Exp* _left = get_exp();
499                 Exp* _right = get_exp();
500                 exp = new AssignExp(loc, *_left, *_right);
501                 break;
502             }
503             case 32:
504             {
505                 OpExp::Oper oper = get_OpExp_Oper();
506                 Exp *left = get_exp();
507                 Exp *right = get_exp();
508                 OpExp *_opexp  = new OpExp(loc, *left, oper, *right);
509                 exp = _opexp;
510                 break;
511             }
512             case 33:
513             {
514                 OpExp::Oper oper = get_OpExp_Oper();
515                 Exp *left = get_exp();
516                 Exp *right = get_exp();
517                 LogicalOpExp *_opexp  =
518                     new LogicalOpExp(loc, *left, oper, *right);
519                 exp = _opexp;
520                 break;
521             }
522             case 34:
523             {
524                 std::list<MatrixLineExp *>* lines = get_MatrixLines();
525                 exp = new MatrixExp(loc, *lines);
526                 break;
527             }
528             case 35:
529             {
530                 Exp* name = get_exp();
531                 std::list<Exp *> * args = get_exps();
532                 exp = new CallExp(loc, *name, *args);
533                 break;
534             }
535             /* SHOULD NEVER HAPPEN
536             case 36: {
537             exp = new MatrixLineExp(*loc);
538             break;
539             }
540             */
541             case 37:
542             {
543                 Exp* name = get_exp();
544                 std::list<Exp *>* args = get_exps();
545                 exp = new CellCallExp(loc, *name, *args);
546                 break;
547             }
548             default:
549                 std::cerr << "Unknown code " << code << std::endl;
550                 exit(2);
551         }
552
553         exp->set_verbose(is_verbose);
554         if (is_break)
555         {
556             exp->break_set();
557         }
558         if (is_breakable)
559         {
560             exp->breakable_set();
561         }
562         if (is_return)
563         {
564             exp->return_set();
565         }
566         if (is_returnable)
567         {
568             exp->returnable_set();
569         }
570         if (is_continue)
571         {
572             exp->continue_set();
573         }
574         if (is_continuable)
575         {
576             exp->continuable_set();
577         }
578
579         if (nodeNumber != 0)
580         {
581             exp->nodeNumber_set(nodeNumber);
582         }
583
584         return exp;
585     }
586
587 public :
588     DeserializeVisitor(unsigned char* buffer) : initial_buf(buffer), buf(buffer) {};
589
590     Exp* deserialize()
591     {
592
593         // scilabVersion and size unused
594         // but get_uintxx used to deserialize macros
595         /*unsigned int size = */get_uint32();
596         // serialization version
597         /*unsigned char scilabVersion[4];
598         scilabVersion[0] = */get_uint8();
599         /*scilabVersion[1] = */get_uint8();
600         /*scilabVersion[2] = */get_uint8();
601         /*scilabVersion[3] = */get_uint8();
602
603         return get_exp();
604     }
605 };
606 }
607 #endif /* !__DESERIALIZER_HXX__  */