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