Line data Source code
1 : #include "vrml_parser.h"
2 :
3 :
4 :
5 :
6 : GlobalVar *gvar = NULL;
7 :
8 : /*************************************************************************************/
9 :
10 : /*************************************************************************************/
11 :
12 :
13 3 : void init_gvar(map<string, DataType> *node_type_map, map<DataType, DataSup *> *type_sup_map,
14 : map<string, DataType> *field_type_map, stack<string> *file_stack,
15 : map<string, Container *> *def_map, map<string, void *> *def_map2)
16 : {
17 3 : if (gvar == NULL) {
18 3 : gvar = new GlobalVar;
19 3 : }
20 :
21 3 : gvar->node_type_map = node_type_map;
22 3 : gvar->type_sup_map = type_sup_map;
23 3 : gvar->field_type_map = field_type_map;
24 3 : gvar->file_stack = file_stack;
25 3 : gvar->def_map = def_map;
26 3 : gvar->def_map2 = def_map2;
27 3 : gvar->frame = NULL;
28 3 : gvar->def_flag = 0;
29 3 : gvar->use_flag = 0;
30 3 : gvar->def_tokn = "";
31 3 : gvar->use_tokn = "";
32 3 : }
33 :
34 : /*************************************************************************************/
35 :
36 : /*************************************************************************************/
37 :
38 339 : map<string, DataType> *get_node_type_map()
39 : {
40 339 : return gvar->node_type_map;
41 : }
42 :
43 :
44 : /*************************************************************************************/
45 :
46 : /*************************************************************************************/
47 :
48 339 : map<DataType, DataSup *> *get_type_sup_map()
49 : {
50 339 : return gvar->type_sup_map;
51 : }
52 :
53 :
54 : /*************************************************************************************/
55 :
56 : /*************************************************************************************/
57 :
58 0 : map<string, Container *> *get_def_map()
59 : {
60 0 : return gvar->def_map;
61 : }
62 :
63 : /*************************************************************************************/
64 :
65 : /*************************************************************************************/
66 :
67 0 : map<string, DataType> *get_field_type_map()
68 : {
69 0 : return gvar->field_type_map;
70 : }
71 :
72 :
73 : /*************************************************************************************/
74 :
75 : /* Stack */
76 :
77 : /*************************************************************************************/
78 :
79 :
80 3 : void init_stack(stack<string> **file_stack)
81 : {
82 :
83 3 : if (*file_stack == NULL) {
84 3 : *file_stack = new stack<string>;
85 3 : }
86 3 : }
87 :
88 : /*************************************************************************************/
89 :
90 : /*************************************************************************************/
91 :
92 2433 : int check_tokn_to_add_stack(string tokn)
93 : {
94 2433 : int value = 0;
95 2433 : map<string, DataType> *node_type_map = NULL;
96 2433 : map<string, DataType>::iterator node_type_map_it;
97 :
98 2433 : node_type_map = gvar->node_type_map;
99 2433 : node_type_map_it = node_type_map->find(tokn);
100 :
101 2433 : if (node_type_map) {
102 :
103 2433 : if (tokn.find("{") != string::npos) {
104 22 : value = 1;
105 2433 : } else if (tokn.find("}") != string::npos) {
106 16 : value = 1;
107 2411 : } else if (node_type_map_it != node_type_map->end()) {
108 18 : value = 1;
109 18 : }
110 2433 : }
111 :
112 2433 : return value;
113 : }
114 :
115 : /*************************************************************************************/
116 :
117 : /*************************************************************************************/
118 :
119 109 : string top_stack()
120 : {
121 109 : stack<string> *file_stack = NULL;
122 109 : file_stack = gvar->file_stack;
123 109 : string value;
124 :
125 109 : if (file_stack) {
126 109 : value = file_stack->top();
127 109 : }
128 :
129 109 : return value;
130 109 : }
131 :
132 : /*************************************************************************************/
133 :
134 : /*************************************************************************************/
135 :
136 53 : int check_matching_bracket(string tokn)
137 : {
138 53 : int value = 0;
139 :
140 53 : if (top_stack() == "{" && tokn == "}") {
141 0 : value = 1;
142 0 : }
143 53 : return value;
144 : }
145 :
146 : /*************************************************************************************/
147 :
148 : /*************************************************************************************/
149 :
150 0 : int top_is_bracket()
151 : {
152 0 : int value = 0;
153 0 : string top;
154 :
155 0 : top = top_stack();
156 :
157 0 : if (top == "}" || top == "{") {
158 0 : value = 1;
159 0 : }
160 0 : return value;
161 0 : }
162 :
163 : /*************************************************************************************/
164 :
165 : /*************************************************************************************/
166 :
167 400 : int size_stack()
168 : {
169 400 : stack<string> *file_stack = NULL;
170 400 : file_stack = gvar->file_stack;
171 400 : int value = 0;
172 :
173 400 : if (file_stack) {
174 400 : value = file_stack->size();
175 400 : }
176 :
177 400 : return value;
178 : }
179 :
180 : /*************************************************************************************/
181 :
182 : /*************************************************************************************/
183 :
184 56 : void push_stack(string tokn)
185 : {
186 56 : stack<string> *file_stack = NULL;
187 56 : file_stack = gvar->file_stack;
188 56 : string value;
189 :
190 56 : if (file_stack) {
191 56 : file_stack->push(tokn);
192 56 : }
193 56 : }
194 :
195 : /*************************************************************************************/
196 :
197 : /*************************************************************************************/
198 :
199 56 : void pop_stack()
200 : {
201 56 : stack<string> *file_stack = NULL;
202 56 : file_stack = gvar->file_stack;
203 56 : string value;
204 :
205 56 : if (file_stack) {
206 56 : file_stack->pop();
207 56 : }
208 56 : }
209 :
210 : /*************************************************************************************/
211 :
212 : /*************************************************************************************/
213 :
214 2433 : void perform_stack_operations(string tokn)
215 : {
216 :
217 2433 : if (check_tokn_to_add_stack(tokn)) {
218 :
219 56 : if (size_stack()) {
220 :
221 53 : if (check_matching_bracket(tokn)) {
222 :
223 : // pop brackets
224 0 : pop_stack();
225 :
226 0 : if (!top_is_bracket()) {
227 :
228 : //pop keyword
229 0 : pop_stack();
230 :
231 0 : }
232 :
233 0 : } else {
234 :
235 53 : push_stack(tokn);
236 :
237 : }
238 :
239 53 : } else {
240 :
241 3 : push_stack(tokn);
242 : }
243 :
244 56 : }
245 2433 : }
246 :
247 : /*************************************************************************************/
248 :
249 : /*************************************************************************************/
250 :
251 2433 : void stack_operations(string tokn)
252 : {
253 2433 : perform_stack_operations(tokn);
254 2433 : }
255 :
256 : /*************************************************************************************/
257 :
258 : /*************************************************************************************/
259 :
260 3 : void debug_stack(string msg)
261 : {
262 :
263 3 : cout << msg <<endl;
264 59 : while (size_stack()) {
265 56 : cout << " stack: "<<top_stack() << endl;
266 56 : pop_stack();
267 : }
268 3 : }
269 :
270 : /*************************************************************************************/
271 :
272 : /*************************************************************************************/
273 :
274 2430 : string get_tokn()
275 : {
276 2430 : string tokn;
277 :
278 : //tokn = get_token();
279 : //stack_operations(tokn);
280 :
281 2430 : tokn = get_token();
282 2430 : stack_operations(tokn);
283 :
284 : // for comments inline
285 2433 : while (tokn.find_first_of("#") != string::npos) {
286 :
287 3 : go_to_next_line();
288 3 : tokn = get_token();
289 3 : stack_operations(tokn);
290 :
291 : }
292 :
293 2430 : check_def_tokn(tokn);
294 2430 : check_use_tokn(tokn);
295 :
296 2430 : return tokn;
297 2430 : }
298 :
299 :
300 : /*************************************************************************************/
301 :
302 : /*************************************************************************************/
303 :
304 :
305 :
306 0 : void check_shape(Container *container)
307 : {
308 0 : PointSet *point_set = NULL;
309 0 : Coordinate *coordinate = NULL;
310 0 : vector<Point *> *coordinate_vec = NULL;
311 0 : vector<Point *>::iterator it;
312 0 : Point *point = NULL;
313 0 : Shape *shape = NULL;
314 :
315 0 : shape = (Shape *) get_container_data(container);
316 :
317 0 : if (shape) {
318 :
319 0 : point_set = shape->point_set;
320 :
321 0 : if (point_set) {
322 :
323 0 : coordinate = point_set->coordinate;
324 0 : if (coordinate) {
325 :
326 0 : coordinate_vec = coordinate->coordinate_vec;
327 0 : if (coordinate_vec) {
328 0 : for (it = coordinate_vec->begin(); it != coordinate_vec->end(); ++it) {
329 0 : point = *it;
330 0 : if (point)
331 0 : cout << "r_shape value: x = " << point->x << " y = " << point->y << " z = "
332 0 : << point->z << endl;
333 0 : }
334 0 : }
335 0 : }
336 0 : }
337 0 : }
338 0 : }
339 :
340 : /*************************************************************************************/
341 :
342 : /*************************************************************************************/
343 :
344 0 : void check_read_point_set(void *args)
345 : {
346 0 : Coordinate *coordinate = NULL;
347 0 : vector<Point *> *coordinate_vec = NULL;
348 0 : vector<Point *>::iterator it;
349 0 : Point *point = NULL;
350 0 : PointSet *point_set = NULL;
351 :
352 0 : point_set = (PointSet *)args;
353 :
354 0 : if (point_set) {
355 :
356 0 : coordinate = point_set->coordinate;
357 0 : if (coordinate) {
358 0 : coordinate_vec = coordinate->coordinate_vec;
359 0 : if (coordinate_vec) {
360 0 : for (it = coordinate_vec->begin(); it != coordinate_vec->end(); ++it) {
361 0 : point = *it;
362 0 : if (point)
363 0 : cout << "r_point_set value: x = " << point->x << " y = " << point->y << " z = " << point->z << endl;
364 0 : }
365 0 : }
366 0 : }
367 0 : }
368 0 : }
369 :
370 :
371 0 : void check_shape2(void *args)
372 : {
373 0 : PointSet *point_set = NULL;
374 0 : Coordinate *coordinate = NULL;
375 0 : vector<Point *> *coordinate_vec = NULL;
376 0 : vector<Point *>::iterator it;
377 0 : Point *point = NULL;
378 0 : Shape *shape = NULL;
379 :
380 0 : shape = (Shape *)args;
381 :
382 0 : if (shape) {
383 :
384 0 : point_set = shape->point_set;
385 :
386 0 : if (point_set) {
387 :
388 0 : coordinate = point_set->coordinate;
389 0 : if (coordinate) {
390 :
391 0 : coordinate_vec = coordinate->coordinate_vec;
392 0 : if (coordinate_vec) {
393 0 : for (it = coordinate_vec->begin(); it != coordinate_vec->end(); ++it) {
394 0 : point = *it;
395 0 : if (point)
396 0 : cout << "r_shape value: x = " << point->x << " y = " << point->y << " z = "
397 0 : << point->z << endl;
398 0 : }
399 0 : }
400 0 : }
401 0 : }
402 0 : }
403 0 : }
404 :
405 0 : void check_transform2(void *args)
406 : {
407 :
408 : int i;
409 : DataType type;
410 0 : void *data = NULL;
411 :
412 0 : data = args;
413 :
414 :
415 :
416 0 : if (data) {
417 :
418 0 : while (data != NULL) {
419 :
420 0 : type = get_node_type(data);
421 :
422 0 : if (type == SHAPE) {
423 :
424 :
425 0 : check_shape2(data);
426 0 : data = NULL;
427 :
428 0 : } else if ( type == TRANSFORM) {
429 :
430 0 : Transform *transform = (Transform *)data;
431 :
432 0 : for (i = 0; i < 3; i++) {
433 0 : cout << "translation[" << i << "] -> " << transform->translation[i] << endl;
434 0 : }
435 :
436 :
437 0 : for (i = 0; i < 3; i++) {
438 0 : cout << "scale[" << i << "] -> " << transform->scale[i] << endl;
439 0 : }
440 :
441 :
442 0 : for (i = 0; i < 4; i++) {
443 0 : cout << "rotation[" << i << "] -> " << transform->rotation[i] << endl;
444 0 : }
445 :
446 0 : data = transform->children;
447 :
448 0 : } else {
449 0 : data = NULL;
450 : }
451 : }
452 0 : }
453 0 : }
454 :
455 : /*************************************************************************************/
456 :
457 : /*************************************************************************************/
458 :
459 3 : void check_frame(vector<Container *> *frame)
460 : {
461 3 : vector<Container *>::iterator it;
462 3 : DataType type = UNKNOWN;
463 :
464 :
465 9 : for (it = frame->begin(); it != frame->end(); ++it) {
466 :
467 6 : type = get_container_type((Container *)*it);
468 :
469 6 : if (type == SHAPE) {
470 0 : cout << "SHAPE" << endl;
471 0 : check_shape(*it);
472 6 : } else if (type == TRANSFORM) {
473 : //check_transform(*it);
474 0 : }
475 6 : }
476 3 : }
477 :
478 :
479 : /*************************************************************************************/
480 :
481 : /*************************************************************************************/
482 :
483 :
484 3 : void debug_def2()
485 : {
486 3 : map<string, void *>::iterator def_map_it;
487 3 : map<string, void *> *def_map = NULL;
488 :
489 3 : def_map = gvar->def_map2;
490 3 : int i = 0;
491 :
492 3 : if (def_map) {
493 :
494 3 : for (def_map_it = def_map->begin(); def_map_it != def_map->end(); ++def_map_it) {
495 0 : cout << "def map key: " << def_map_it->first <<" value: " << def_map_it->second << endl;
496 0 : i++;
497 0 : if (i == 1) {
498 0 : cout << endl << "@@@@@@@@@@ TRANSFORM @@@@@@@@@@@" << endl;
499 0 : check_transform2(def_map_it->second);
500 0 : }
501 0 : if (i == 2) {
502 0 : cout << endl << "@@@@@@@@@@ SHAPE @@@@@@@@@@@" << endl;
503 0 : check_shape2(def_map_it->second);
504 :
505 0 : }
506 :
507 0 : if (i == 3) {
508 0 : cout << endl << "@@@@@@@@@@ POINTSET @@@@@@@@@@@" << endl;
509 0 : check_read_point_set(def_map_it->second);
510 :
511 0 : }
512 0 : }
513 3 : }
514 3 : }
515 :
516 :
517 :
518 : /*************************************************************************************/
519 :
520 : /*************************************************************************************/
521 :
522 339 : void *call_node_read_function(string tokn, void *args)
523 : {
524 :
525 339 : map<string, DataType> *node_type_map = NULL;
526 339 : map<string, DataType>::iterator node_type_map_it;
527 :
528 339 : map<DataType, DataSup *> *type_sup_map = NULL;
529 339 : map<DataType, DataSup *>::iterator type_sup_map_it;
530 :
531 339 : void *data = NULL;
532 :
533 339 : node_type_map = get_node_type_map();
534 339 : type_sup_map = get_type_sup_map();
535 :
536 339 : node_type_map_it = node_type_map->find(tokn);
537 :
538 339 : if (node_type_map_it != node_type_map->end()) {
539 :
540 18 : type_sup_map_it = type_sup_map->find(node_type_map_it->second);
541 :
542 18 : if (type_sup_map_it != type_sup_map->end()) {
543 :
544 6 : data = type_sup_map_it->second->read_node_fun(args);
545 6 : }
546 18 : }
547 339 : return data;
548 : }
549 :
550 : /*************************************************************************************/
551 :
552 : /*************************************************************************************/
553 :
554 :
555 0 : void *call_field_read_function(string tokn, void *args)
556 : {
557 :
558 0 : map<string, DataType> *field_type_map = NULL;
559 0 : map<string, DataType>::iterator field_type_map_it;
560 :
561 0 : map<DataType, DataSup *> *type_sup_map = NULL;
562 0 : map<DataType, DataSup *>::iterator type_sup_map_it;
563 :
564 0 : void *data = NULL;
565 :
566 0 : field_type_map = get_field_type_map();
567 0 : type_sup_map = get_type_sup_map();
568 :
569 0 : field_type_map_it = field_type_map->find(tokn);
570 :
571 0 : if (field_type_map_it != field_type_map->end()) {
572 :
573 0 : type_sup_map_it = type_sup_map->find(field_type_map_it->second);
574 :
575 0 : if (type_sup_map_it != type_sup_map->end()) {
576 :
577 0 : data = type_sup_map_it->second->read_field_fun(args);
578 0 : }
579 0 : }
580 0 : return data;
581 : }
582 :
583 : /*************************************************************************************/
584 :
585 : /*************************************************************************************/
586 :
587 3 : void read_vrml(char *filename)
588 : {
589 3 : string tokn;
590 3 : ifstream *fp = NULL;
591 :
592 3 : map<string, DataType> *node_type_map = NULL;
593 :
594 3 : map<DataType, DataSup *> *type_sup_map = NULL;
595 :
596 3 : map<string, DataType> *field_type_map = NULL;
597 :
598 3 : stack<string> *file_stack = NULL;
599 :
600 3 : vector<Container *> *frame = NULL;
601 :
602 3 : map<string, Container *> *def = NULL;
603 :
604 3 : map<string, void *> *def_map2 = NULL;
605 :
606 3 : void *data = NULL;
607 :
608 3 : DataType data_type = UNKNOWN;
609 :
610 3 : init_node_type_map(&node_type_map);
611 3 : init_field_type_map(&field_type_map);
612 3 : init_type_sup_map(&type_sup_map);
613 3 : init_stack(&file_stack);
614 3 : init_frame(&frame);
615 3 : init_def(&def);
616 3 : init_def_map2(&def_map2);
617 :
618 3 : init_gvar(node_type_map, type_sup_map, field_type_map, file_stack, def, def_map2);
619 :
620 3 : gvar->frame = frame;
621 :
622 3 : int i = 0;
623 3 : int def_flag = 0;
624 3 : string def_tokn;
625 :
626 : //fp = open_file("/home/alepapadop/VRML/5pointset.wrl");
627 : //fp = open_file("/home/alepapadop/VRML/a.wrl");
628 3 : fp = open_file(filename);
629 :
630 286 : while (fp->good()) {
631 :
632 285 : tokn = get_tokn();
633 :
634 285 : if (gvar->def_flag) {
635 0 : def_flag = 1;
636 0 : def_tokn = gvar->def_tokn;
637 : //gvar->def_flag = 0;
638 : //gvar->def_tokn = "";
639 0 : }
640 :
641 285 : data = call_node_read_function(tokn, NULL);
642 :
643 285 : if (def_flag && data !=NULL) {
644 0 : add_to_def(def_tokn, (Container *)data);
645 0 : add_to_def_map(def_tokn, data);
646 : //(*(gvar->def_map2))[def_tokn] = data;
647 0 : }
648 285 : if (data != NULL) {
649 6 : frame->push_back((Container *)data);
650 6 : }
651 285 : data = NULL;
652 :
653 :
654 : // lthos auto, edw einai pou tha mpainei sto file data to frame
655 285 : if (!size_stack()) {
656 6 : init_frame(&frame);
657 6 : gvar->frame = frame;
658 6 : }
659 :
660 285 : data_type = UNKNOWN;
661 285 : i ++;
662 285 : if (i == 100) break;
663 : }
664 3 : check_frame(frame);
665 3 : debug_stack("\nSTACK \n\n");
666 : // debug_def();
667 3 : debug_def2();
668 3 : }
669 :
670 :
671 :
672 :
673 :
674 :
|
