Line data Source code
1 : /*
2 : * GPAC - Multimedia Framework C SDK
3 : *
4 : * Authors: Jean Le Feuvre
5 : * Copyright (c) Telecom ParisTech 2000-2012
6 : * All rights reserved
7 : *
8 : * This file is part of GPAC / BIFS codec sub-project
9 : *
10 : * GPAC is free software; you can redistribute it and/or modify
11 : * it under the terms of the GNU Lesser General Public License as published by
12 : * the Free Software Foundation; either version 2, or (at your option)
13 : * any later version.
14 : *
15 : * GPAC is distributed in the hope that it will be useful,
16 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 : * GNU Lesser General Public License for more details.
19 : *
20 : * You should have received a copy of the GNU Lesser General Public
21 : * License along with this library; see the file COPYING. If not, write to
22 : * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 : *
24 : */
25 :
26 :
27 : #include "script.h"
28 :
29 : #if !defined(GPAC_DISABLE_BIFS) && defined(GPAC_HAS_QJS)
30 :
31 : #define BINOP_MINVAL ET_EQ
32 :
33 : typedef struct
34 : {
35 : GF_Node *script;
36 : GF_BifsDecoder *codec;
37 : GF_BitStream *bs;
38 : char *string;
39 : u32 length;
40 : GF_List *identifiers;
41 : char *new_line;
42 : u32 indent;
43 : } ScriptParser;
44 :
45 :
46 : void SFS_Identifier(ScriptParser *parser);
47 : void SFS_Arguments(ScriptParser *parser, Bool is_var);
48 : void SFS_StatementBlock(ScriptParser *parser, Bool functBody);
49 : void SFS_Statement(ScriptParser *parser);
50 : void SFS_IfStatement(ScriptParser *parser);
51 : void SFS_SwitchStatement(ScriptParser *parser);
52 : void SFS_ForStatement(ScriptParser *parser);
53 : void SFS_WhileStatement(ScriptParser *parser);
54 : void SFS_ReturnStatement(ScriptParser *parser);
55 : void SFS_CompoundExpression(ScriptParser *parser);
56 : void SFS_OptionalExpression(ScriptParser *parser);
57 : void SFS_Expression(ScriptParser *parser);
58 : void SFS_NewObject(ScriptParser *parser);
59 : void SFS_ArrayDeref(ScriptParser *parser);
60 : void SFS_FunctionCall(ScriptParser *parser);
61 : void SFS_ObjectMemberAccess(ScriptParser *parser);
62 : void SFS_ObjectMethodCall(ScriptParser *parser);
63 : void SFS_Params(ScriptParser *parser);
64 : void SFS_GetNumber(ScriptParser *parser);
65 : void SFS_GetString(ScriptParser *parser);
66 : void SFS_GetBoolean(ScriptParser *parser);
67 :
68 : #define PARSER_STEP_ALLOC 500
69 :
70 7804 : static void SFS_AddString(ScriptParser *parser, char *str)
71 : {
72 : char *new_str;
73 7804 : if (!str) return;
74 7801 : if (strlen(parser->string) + strlen(str) >= parser->length) {
75 27 : parser->length += PARSER_STEP_ALLOC;
76 27 : new_str = (char *)gf_malloc(sizeof(char)*parser->length);
77 27 : strcpy(new_str, parser->string);
78 27 : gf_free(parser->string);
79 27 : parser->string = new_str;
80 : }
81 7801 : strcat(parser->string, str);
82 : }
83 :
84 600 : static void SFS_AddInt(ScriptParser *parser, s32 val)
85 : {
86 : char msg[500];
87 : sprintf(msg, "%d", val);
88 600 : SFS_AddString(parser, msg);
89 600 : }
90 20 : static void SFS_AddChar(ScriptParser *parser, char c)
91 : {
92 : char msg[2];
93 20 : sprintf(msg, "%c", c);
94 20 : SFS_AddString(parser, msg);
95 20 : }
96 :
97 :
98 30 : GF_Err ParseScriptField(ScriptParser *parser)
99 : {
100 : GF_ScriptField *field;
101 : GF_Err e;
102 : u32 eventType, fieldType;
103 : char name[1000];
104 : GF_FieldInfo info;
105 :
106 30 : eventType = gf_bs_read_int(parser->bs, 2);
107 30 : fieldType = gf_bs_read_int(parser->bs, 6);
108 30 : gf_bifs_dec_name(parser->bs, name);
109 30 : field = gf_sg_script_field_new(parser->script, eventType, fieldType, name);
110 30 : if (!field) return GF_NON_COMPLIANT_BITSTREAM;
111 :
112 : //save the name in the list of identifiers
113 30 : gf_list_add(parser->identifiers, gf_strdup(name));
114 :
115 30 : if (parser->codec->pCurrentProto) {
116 0 : Bool isISfield = (Bool)gf_bs_read_int(parser->bs, 1);
117 0 : if (isISfield) {
118 0 : u32 numProtoField = gf_sg_proto_get_field_count(parser->codec->pCurrentProto);
119 0 : u32 numBits = gf_get_bit_size(numProtoField - 1);
120 0 : u32 field_all = gf_bs_read_int(parser->bs, numBits);
121 0 : e = gf_sg_script_field_get_info(field, &info);
122 0 : if (e) return e;
123 0 : e = gf_sg_proto_field_set_ised(parser->codec->pCurrentProto, field_all, parser->script, info.fieldIndex);
124 0 : return e;
125 : }
126 : }
127 : /*get default value*/
128 30 : if (eventType == GF_SG_SCRIPT_TYPE_FIELD) {
129 15 : if (gf_bs_read_int(parser->bs, 1)) {
130 15 : e = gf_sg_script_field_get_info(field, &info);
131 15 : if (e) return e;
132 15 : gf_bifs_dec_field(parser->codec, parser->bs, parser->script, &info, GF_FALSE);
133 : }
134 : }
135 :
136 30 : return parser->codec->LastError;
137 : }
138 :
139 : static void SFS_IncIndent(ScriptParser *pars) {
140 270 : pars->indent++;
141 : }
142 : static void SFS_DecIndent(ScriptParser *pars) {
143 270 : pars->indent--;
144 : }
145 : static void SFS_Space(ScriptParser *pars) {
146 30 : if (pars->new_line) SFS_AddString(pars, " ");
147 : }
148 1265 : static void SFS_Indent(ScriptParser *pars)
149 : {
150 : u32 i;
151 1265 : if (pars->new_line) {
152 1036 : for (i=0; i<pars->indent; i++) SFS_AddString(pars, " ");
153 : }
154 1265 : }
155 : static GFINLINE void SFS_Line(ScriptParser *parser)
156 : {
157 1355 : if (parser->new_line) {
158 1084 : SFS_AddString(parser, parser->new_line);
159 : }
160 : }
161 :
162 :
163 15 : GF_Err SFScript_Parse(GF_BifsDecoder *codec, SFScript *script_field, GF_BitStream *bs, GF_Node *n)
164 : {
165 : GF_Err e;
166 : u32 i, count, nbBits;
167 : char *ptr;
168 : ScriptParser parser;
169 : e = GF_OK;
170 15 : if (gf_node_get_tag(n) != TAG_MPEG4_Script) return GF_NON_COMPLIANT_BITSTREAM;
171 :
172 15 : parser.codec = codec;
173 15 : parser.script = n;
174 15 : parser.bs = bs;
175 15 : parser.length = 500;
176 15 : parser.string = (char *) gf_malloc(sizeof(char)* parser.length);
177 15 : parser.string[0] = 0;
178 15 : parser.identifiers = gf_list_new();
179 15 : parser.new_line = (char *) (codec->dec_memory_mode ? "\n" : NULL);
180 15 : parser.indent = 0;
181 :
182 : //first parse fields
183 :
184 15 : if (gf_bs_read_int(bs, 1)) {
185 : //endFlag
186 45 : while (!gf_bs_read_int(bs, 1)) {
187 30 : e = ParseScriptField(&parser);
188 30 : if (e) goto exit;
189 : }
190 : } else {
191 0 : nbBits = gf_bs_read_int(bs, 4);
192 0 : count = gf_bs_read_int(bs, nbBits);
193 0 : for (i=0; i<count; i++) {
194 0 : e = ParseScriptField(&parser);
195 0 : if (e) goto exit;
196 : }
197 : }
198 : //reserevd
199 15 : gf_bs_read_int(bs, 1);
200 : //then parse
201 15 : SFS_AddString(&parser, "javascript:");
202 15 : SFS_AddString(&parser, parser.new_line);
203 :
204 : //hasFunction
205 60 : while (gf_bs_read_int(bs, 1)) {
206 30 : SFS_AddString(&parser, "function ");
207 30 : SFS_Identifier(&parser);
208 30 : SFS_Arguments(&parser, GF_FALSE);
209 : SFS_Space(&parser);
210 30 : SFS_StatementBlock(&parser, GF_TRUE);
211 : SFS_Line(&parser);
212 : }
213 :
214 : SFS_Line(&parser);
215 :
216 15 : if (script_field->script_text) gf_free(script_field->script_text);
217 15 : script_field->script_text = (char *) gf_strdup(parser.string);
218 :
219 0 : exit:
220 : //clean up
221 210 : while (gf_list_count(parser.identifiers)) {
222 195 : ptr = (char *)gf_list_get(parser.identifiers, 0);
223 195 : gf_free(ptr);
224 195 : gf_list_rem(parser.identifiers, 0);
225 : }
226 15 : gf_list_del(parser.identifiers);
227 15 : if (parser.string) gf_free(parser.string);
228 : return e;
229 : }
230 :
231 :
232 :
233 1445 : void SFS_Identifier(ScriptParser *parser)
234 : {
235 : u32 index;
236 : char name[500];
237 :
238 1445 : if (parser->codec->LastError) return;
239 :
240 : //received
241 1445 : if (gf_bs_read_int(parser->bs, 1)) {
242 1280 : index = gf_bs_read_int(parser->bs, gf_get_bit_size(gf_list_count(parser->identifiers) - 1));
243 1280 : SFS_AddString(parser, (char *)gf_list_get(parser->identifiers, index));
244 : }
245 : //parse
246 : else {
247 165 : gf_bifs_dec_name(parser->bs, name);
248 165 : gf_list_add(parser->identifiers, gf_strdup(name));
249 165 : SFS_AddString(parser, name);
250 : }
251 : }
252 :
253 60 : void SFS_Arguments(ScriptParser *parser, Bool is_var)
254 : {
255 : u32 val;
256 60 : if (parser->codec->LastError) return;
257 60 : if (!is_var) SFS_AddString(parser, "(");
258 :
259 60 : val = gf_bs_read_int(parser->bs, 1);
260 165 : while (val) {
261 45 : SFS_Identifier(parser);
262 45 : val = gf_bs_read_int(parser->bs, 1);
263 45 : if (val) SFS_AddString(parser, ",");
264 : }
265 60 : if (!is_var) SFS_AddString(parser, ")");
266 : }
267 :
268 270 : void SFS_StatementBlock(ScriptParser *parser, Bool funcBody)
269 : {
270 270 : if (parser->codec->LastError) return;
271 :
272 270 : if (gf_bs_read_int(parser->bs, 1)) {
273 270 : SFS_AddString(parser, "{");
274 : SFS_IncIndent(parser);
275 :
276 1220 : while (gf_bs_read_int(parser->bs, 1)) {
277 : SFS_Line(parser);
278 950 : SFS_Indent(parser);
279 950 : SFS_Statement(parser);
280 : }
281 : SFS_DecIndent(parser);
282 : SFS_Line(parser);
283 270 : SFS_Indent(parser);
284 270 : SFS_AddString(parser, "}");
285 0 : } else if (funcBody) {
286 0 : SFS_AddString(parser, "{");
287 0 : SFS_Statement(parser);
288 0 : SFS_AddString(parser, "}");
289 : } else {
290 0 : SFS_Statement(parser);
291 : }
292 : }
293 :
294 :
295 950 : void SFS_Statement(ScriptParser *parser)
296 : {
297 : u32 val;
298 950 : if (parser->codec->LastError) return;
299 :
300 950 : val = gf_bs_read_int(parser->bs, NUMBITS_STATEMENT);
301 950 : switch (val) {
302 150 : case ST_IF:
303 150 : SFS_IfStatement(parser);
304 150 : break;
305 15 : case ST_FOR:
306 15 : SFS_ForStatement(parser);
307 15 : break;
308 15 : case ST_WHILE:
309 15 : SFS_WhileStatement(parser);
310 15 : break;
311 15 : case ST_RETURN:
312 15 : SFS_ReturnStatement(parser);
313 15 : break;
314 30 : case ST_BREAK:
315 30 : SFS_AddString(parser, "break;");
316 30 : break;
317 15 : case ST_CONTINUE:
318 15 : SFS_AddString(parser, "continue;");
319 15 : break;
320 695 : case ST_COMPOUND_EXPR:
321 695 : SFS_CompoundExpression(parser);
322 695 : SFS_AddString(parser, ";");
323 695 : break;
324 15 : case ST_SWITCH:
325 15 : SFS_SwitchStatement(parser);
326 15 : break;
327 : }
328 : }
329 :
330 150 : void SFS_IfStatement(ScriptParser *parser)
331 : {
332 150 : if (parser->codec->LastError) return;
333 150 : SFS_AddString(parser, "if (");
334 150 : SFS_CompoundExpression(parser);
335 150 : SFS_AddString(parser, ") ");
336 150 : SFS_StatementBlock(parser, GF_FALSE);
337 : //has else
338 150 : if (gf_bs_read_int(parser->bs, 1)) {
339 : SFS_Line(parser);
340 15 : SFS_Indent(parser);
341 15 : SFS_AddString(parser, "else ");
342 15 : SFS_StatementBlock(parser, GF_FALSE);
343 : }
344 : }
345 :
346 15 : void SFS_SwitchStatement(ScriptParser *parser)
347 : {
348 : u32 numBits, caseValue;
349 :
350 15 : if (parser->codec->LastError) return;
351 15 : SFS_AddString(parser, "switch (");
352 15 : SFS_CompoundExpression(parser);
353 15 : SFS_AddString(parser, ")");
354 15 : SFS_AddString(parser, "{");
355 : SFS_Line(parser);
356 :
357 15 : numBits = gf_bs_read_int(parser->bs, 5);
358 : do {
359 15 : SFS_Indent(parser);
360 15 : SFS_AddString(parser, "case ");
361 15 : caseValue = gf_bs_read_int(parser->bs, numBits);
362 15 : SFS_AddInt(parser, caseValue);
363 15 : SFS_AddString(parser, ":");
364 : SFS_Line(parser);
365 15 : SFS_Indent(parser);
366 15 : SFS_StatementBlock(parser, GF_FALSE);
367 : SFS_Line(parser);
368 : }
369 15 : while (gf_bs_read_int(parser->bs, 1));
370 :
371 : //default
372 15 : if (gf_bs_read_int(parser->bs, 1)) {
373 15 : SFS_AddString(parser, "default:");
374 : SFS_Line(parser);
375 15 : SFS_StatementBlock(parser, GF_FALSE);
376 : }
377 15 : SFS_AddString(parser, "}");
378 : }
379 :
380 15 : void SFS_ForStatement(ScriptParser *parser)
381 : {
382 15 : if (parser->codec->LastError) return;
383 15 : SFS_AddString(parser, "for (");
384 15 : SFS_OptionalExpression(parser);
385 15 : SFS_AddString(parser, ";");
386 15 : SFS_OptionalExpression(parser);
387 15 : SFS_AddString(parser, ";");
388 15 : SFS_OptionalExpression(parser);
389 15 : SFS_AddString(parser, ")");
390 :
391 15 : SFS_StatementBlock(parser, GF_FALSE);
392 : }
393 :
394 15 : void SFS_WhileStatement(ScriptParser *parser)
395 : {
396 15 : if (parser->codec->LastError) return;
397 15 : SFS_AddString(parser, "while (");
398 15 : SFS_CompoundExpression(parser);
399 15 : SFS_AddString(parser, ")");
400 :
401 15 : SFS_StatementBlock(parser, GF_FALSE);
402 : }
403 :
404 15 : void SFS_ReturnStatement(ScriptParser *parser)
405 : {
406 15 : if (parser->codec->LastError) return;
407 15 : SFS_AddString(parser, "return");
408 15 : if (gf_bs_read_int(parser->bs, 1)) {
409 0 : SFS_AddString(parser, " ");
410 0 : SFS_CompoundExpression(parser);
411 : }
412 15 : SFS_AddString(parser, ";");
413 : SFS_Line(parser);
414 : }
415 :
416 965 : void SFS_CompoundExpression(ScriptParser *parser)
417 : {
418 965 : if (parser->codec->LastError) return;
419 965 : SFS_Expression(parser);
420 965 : if (! gf_bs_read_int(parser->bs, 1)) return;
421 0 : SFS_AddString(parser, ",");
422 : SFS_CompoundExpression(parser);
423 : }
424 :
425 45 : void SFS_OptionalExpression(ScriptParser *parser)
426 : {
427 45 : if (parser->codec->LastError) return;
428 45 : if (gf_bs_read_int(parser->bs, 1)) {
429 45 : SFS_CompoundExpression(parser);
430 : }
431 : }
432 :
433 :
434 2140 : void SFS_Expression(ScriptParser *parser)
435 : {
436 3180 : u32 val = gf_bs_read_int(parser->bs, NUMBITS_EXPR_TYPE);
437 3180 : if (parser->codec->LastError) return;
438 :
439 3180 : switch(val) {
440 15 : case ET_CURVED_EXPR:
441 15 : SFS_AddString(parser, "(");
442 15 : SFS_CompoundExpression(parser);
443 15 : SFS_AddString(parser, ")");
444 15 : break;
445 15 : case ET_NEGATIVE:
446 15 : SFS_AddString(parser, "-");
447 : SFS_Expression(parser);
448 15 : break;
449 30 : case ET_NOT:
450 30 : SFS_AddString(parser, "!");
451 : SFS_Expression(parser);
452 30 : break;
453 15 : case ET_ONESCOMP:
454 15 : SFS_AddString(parser, "~");
455 : SFS_Expression(parser);
456 15 : break;
457 15 : case ET_INCREMENT:
458 15 : SFS_AddString(parser, "++");
459 : SFS_Expression(parser);
460 15 : break;
461 15 : case ET_DECREMENT:
462 15 : SFS_AddString(parser, "--");
463 : SFS_Expression(parser);
464 15 : break;
465 30 : case ET_POST_INCREMENT:
466 30 : SFS_Expression(parser);
467 30 : SFS_AddString(parser, "++");
468 30 : break;
469 15 : case ET_POST_DECREMENT:
470 15 : SFS_Expression(parser);
471 15 : SFS_AddString(parser, "--");
472 15 : break;
473 45 : case ET_CONDTEST:
474 45 : SFS_Expression(parser);
475 45 : SFS_AddString(parser, " ? ");
476 45 : SFS_Expression(parser);
477 45 : SFS_AddString(parser, " : ");
478 : SFS_Expression(parser);
479 45 : break;
480 45 : case ET_STRING:
481 45 : SFS_AddString(parser, "'");
482 45 : SFS_GetString(parser);
483 45 : SFS_AddString(parser, "'");
484 45 : break;
485 590 : case ET_NUMBER:
486 590 : SFS_GetNumber(parser);
487 590 : break;
488 1280 : case ET_IDENTIFIER:
489 1280 : SFS_Identifier(parser);
490 1280 : break;
491 15 : case ET_FUNCTION_CALL:
492 15 : SFS_FunctionCall(parser);
493 15 : break;
494 15 : case ET_NEW:
495 15 : SFS_NewObject(parser);
496 15 : break;
497 30 : case ET_OBJECT_MEMBER_ACCESS:
498 30 : SFS_ObjectMemberAccess(parser);
499 30 : break;
500 30 : case ET_OBJECT_METHOD_CALL:
501 30 : SFS_ObjectMethodCall(parser);
502 30 : break;
503 30 : case ET_ARRAY_DEREFERENCE:
504 30 : SFS_ArrayDeref(parser);
505 30 : break;
506 :
507 15 : case ET_MULTIPLY:
508 15 : SFS_Expression(parser);
509 15 : SFS_AddString(parser, "*");
510 : SFS_Expression(parser);
511 15 : break;
512 15 : case ET_DIVIDE:
513 15 : SFS_Expression(parser);
514 15 : SFS_AddString(parser, "/");
515 : SFS_Expression(parser);
516 15 : break;
517 15 : case ET_MOD:
518 15 : SFS_Expression(parser);
519 15 : SFS_AddString(parser, "%");
520 : SFS_Expression(parser);
521 15 : break;
522 15 : case ET_PLUS:
523 15 : SFS_Expression(parser);
524 15 : SFS_AddString(parser, "+");
525 : SFS_Expression(parser);
526 15 : break;
527 15 : case ET_MINUS:
528 15 : SFS_Expression(parser);
529 15 : SFS_AddString(parser, "-");
530 : SFS_Expression(parser);
531 15 : break;
532 15 : case ET_LSHIFT:
533 15 : SFS_Expression(parser);
534 15 : SFS_AddString(parser, "<<");
535 : SFS_Expression(parser);
536 15 : break;
537 15 : case ET_RSHIFT:
538 15 : SFS_Expression(parser);
539 15 : SFS_AddString(parser, ">>");
540 : SFS_Expression(parser);
541 15 : break;
542 15 : case ET_RSHIFTFILL:
543 15 : SFS_Expression(parser);
544 15 : SFS_AddString(parser, ">>>");
545 : SFS_Expression(parser);
546 15 : break;
547 15 : case ET_AND:
548 15 : SFS_Expression(parser);
549 15 : SFS_AddString(parser, "&");
550 : SFS_Expression(parser);
551 15 : break;
552 15 : case ET_XOR:
553 15 : SFS_Expression(parser);
554 15 : SFS_AddString(parser, "^");
555 : SFS_Expression(parser);
556 15 : break;
557 15 : case ET_OR:
558 15 : SFS_Expression(parser);
559 15 : SFS_AddString(parser, "|");
560 : SFS_Expression(parser);
561 15 : break;
562 30 : case ET_LT:
563 30 : SFS_Expression(parser);
564 30 : SFS_AddString(parser, "<");
565 : SFS_Expression(parser);
566 30 : break;
567 15 : case ET_LE:
568 15 : SFS_Expression(parser);
569 15 : SFS_AddString(parser, "<=");
570 : SFS_Expression(parser);
571 15 : break;
572 15 : case ET_GT:
573 15 : SFS_Expression(parser);
574 15 : SFS_AddString(parser, ">");
575 : SFS_Expression(parser);
576 15 : break;
577 15 : case ET_GE:
578 15 : SFS_Expression(parser);
579 15 : SFS_AddString(parser, ">=");
580 : SFS_Expression(parser);
581 15 : break;
582 30 : case ET_EQ:
583 30 : SFS_Expression(parser);
584 30 : SFS_AddString(parser, "==");
585 : SFS_Expression(parser);
586 30 : break;
587 15 : case ET_NE:
588 15 : SFS_Expression(parser);
589 15 : SFS_AddString(parser, "!=");
590 : SFS_Expression(parser);
591 15 : break;
592 15 : case ET_LAND:
593 15 : SFS_Expression(parser);
594 15 : SFS_AddString(parser, "&&");
595 : SFS_Expression(parser);
596 15 : break;
597 15 : case ET_LOR:
598 15 : SFS_Expression(parser);
599 15 : SFS_AddString(parser, "||");
600 : SFS_Expression(parser);
601 15 : break;
602 410 : case ET_ASSIGN:
603 410 : SFS_Expression(parser);
604 410 : SFS_AddString(parser, "=");
605 : SFS_Expression(parser);
606 410 : break;
607 15 : case ET_PLUSEQ:
608 15 : SFS_Expression(parser);
609 15 : SFS_AddString(parser, "+=");
610 : SFS_Expression(parser);
611 15 : break;
612 15 : case ET_MINUSEQ:
613 15 : SFS_Expression(parser);
614 15 : SFS_AddString(parser, "-=");
615 : SFS_Expression(parser);
616 15 : break;
617 15 : case ET_MULTIPLYEQ:
618 15 : SFS_Expression(parser);
619 15 : SFS_AddString(parser, "*=");
620 : SFS_Expression(parser);
621 15 : break;
622 15 : case ET_DIVIDEEQ:
623 15 : SFS_Expression(parser);
624 15 : SFS_AddString(parser, "/=");
625 : SFS_Expression(parser);
626 15 : break;
627 30 : case ET_MODEQ:
628 30 : SFS_Expression(parser);
629 30 : SFS_AddString(parser, "%=");
630 : SFS_Expression(parser);
631 30 : break;
632 15 : case ET_LSHIFTEQ:
633 15 : SFS_Expression(parser);
634 15 : SFS_AddString(parser, "<<=");
635 : SFS_Expression(parser);
636 15 : break;
637 15 : case ET_RSHIFTEQ:
638 15 : SFS_Expression(parser);
639 15 : SFS_AddString(parser, ">>=");
640 : SFS_Expression(parser);
641 15 : break;
642 15 : case ET_RSHIFTFILLEQ:
643 15 : SFS_Expression(parser);
644 15 : SFS_AddString(parser, ">>>=");
645 : SFS_Expression(parser);
646 15 : break;
647 15 : case ET_ANDEQ:
648 15 : SFS_Expression(parser);
649 15 : SFS_AddString(parser, "&=");
650 : SFS_Expression(parser);
651 15 : break;
652 15 : case ET_XOREQ:
653 15 : SFS_Expression(parser);
654 15 : SFS_AddString(parser, "^=");
655 : SFS_Expression(parser);
656 15 : break;
657 15 : case ET_OREQ:
658 15 : SFS_Expression(parser);
659 15 : SFS_AddString(parser, "|=");
660 : SFS_Expression(parser);
661 15 : break;
662 15 : case ET_BOOLEAN:
663 15 : SFS_GetBoolean(parser);
664 15 : break;
665 15 : case ET_VAR:
666 15 : SFS_AddString(parser, "var ");
667 15 : SFS_Arguments(parser, GF_TRUE);
668 15 : break;
669 15 : case ET_FUNCTION_ASSIGN:
670 15 : SFS_AddString(parser, "function ");
671 15 : SFS_Arguments(parser, GF_FALSE);
672 15 : SFS_StatementBlock(parser, GF_TRUE);
673 15 : break;
674 : default:
675 : assert(0);
676 : break;
677 : }
678 : }
679 :
680 15 : void SFS_NewObject(ScriptParser *parser)
681 : {
682 15 : if (parser->codec->LastError) return;
683 15 : SFS_AddString(parser, "new ");
684 15 : SFS_Identifier(parser);
685 15 : SFS_AddString(parser, "(");
686 15 : SFS_Params(parser);
687 15 : SFS_AddString(parser, ") ");
688 : }
689 :
690 30 : void SFS_ArrayDeref(ScriptParser *parser)
691 : {
692 30 : if (parser->codec->LastError) return;
693 30 : SFS_Expression(parser);
694 30 : SFS_AddString(parser, "[");
695 30 : SFS_CompoundExpression(parser);
696 30 : SFS_AddString(parser, "]");
697 : }
698 :
699 15 : void SFS_FunctionCall(ScriptParser *parser)
700 : {
701 15 : if (parser->codec->LastError) return;
702 15 : SFS_Identifier(parser);
703 15 : SFS_AddString(parser, "(");
704 15 : SFS_Params(parser);
705 15 : SFS_AddString(parser, ")");
706 : }
707 :
708 30 : void SFS_ObjectMemberAccess(ScriptParser *parser)
709 : {
710 30 : if (parser->codec->LastError) return;
711 30 : SFS_Expression(parser);
712 30 : SFS_AddString(parser, ".");
713 30 : SFS_Identifier(parser);
714 : }
715 :
716 :
717 30 : void SFS_ObjectMethodCall(ScriptParser *parser)
718 : {
719 30 : if (parser->codec->LastError) return;
720 30 : SFS_Expression(parser);
721 30 : SFS_AddString(parser, ".");
722 30 : SFS_Identifier(parser);
723 30 : SFS_AddString(parser, "(");
724 30 : SFS_Params(parser);
725 30 : SFS_AddString(parser, ")");
726 : }
727 :
728 60 : void SFS_Params(ScriptParser *parser)
729 : {
730 : u32 val;
731 60 : if (parser->codec->LastError) return;
732 60 : val = gf_bs_read_int(parser->bs, 1);
733 165 : while (val) {
734 45 : SFS_Expression(parser);
735 45 : val = gf_bs_read_int(parser->bs, 1);
736 45 : if(val) SFS_AddString(parser, ",");
737 : }
738 : }
739 :
740 590 : void SFS_GetNumber(ScriptParser *parser)
741 : {
742 : u32 val, nbBits;
743 :
744 590 : if (parser->codec->LastError) return;
745 : // integer
746 590 : if (gf_bs_read_int(parser->bs, 1)) {
747 585 : nbBits = gf_bs_read_int(parser->bs, 5);
748 585 : val = gf_bs_read_int(parser->bs, nbBits);
749 585 : SFS_AddInt(parser, val);
750 585 : return;
751 : }
752 : // real number
753 5 : val = gf_bs_read_int(parser->bs, 4);
754 30 : while ( val != 15) {
755 20 : if (val<=9) {
756 15 : SFS_AddChar(parser, (char) (val + '0') );
757 5 : } else if (val==10) {
758 5 : SFS_AddChar(parser, '.');
759 0 : } else if (val==11) {
760 0 : SFS_AddChar(parser, 'E');
761 0 : } else if (val==12) {
762 0 : SFS_AddChar(parser, '-');
763 : }
764 20 : val = gf_bs_read_int(parser->bs, 4);
765 : }
766 : }
767 :
768 45 : void SFS_GetString(ScriptParser *parser)
769 : {
770 : char name[1000];
771 45 : if (parser->codec->LastError) return;
772 45 : gf_bifs_dec_name(parser->bs, name);
773 45 : SFS_AddString(parser, name);
774 : }
775 :
776 15 : void SFS_GetBoolean(ScriptParser *parser)
777 : {
778 15 : if (parser->codec->LastError) return;
779 15 : if (gf_bs_read_int(parser->bs, 1)) {
780 15 : SFS_AddString(parser, "true");
781 : } else {
782 0 : SFS_AddString(parser, "false");
783 : }
784 : }
785 :
786 : #endif /*!defined(GPAC_DISABLE_BIFS) && defined(GPAC_HAS_QJS)*/
|
