?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
upgrade to xpdf 3.00.
[swftools.git] / lib / action / compile.c
blobb658dd2eef918a62c6dd3febd714ad80e63ea3d8
1 /*
2 Ming, an SWF output library
3 Copyright (C) 2002 Opaque Industries - http://www.opaque.net/
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 #ifndef WIN32
21 #include <unistd.h>
22 #endif
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <ctype.h>
27 #include <string.h>
28
29 #include "libming.h"
30 #include "compile.h"
31 #include "action.h"
32 #include "blocks/error.h"
33
34
35 static int nConstants = {0}, maxConstants = {0}, sizeConstants = {0};
36 static char **constants;
37
38 /* XXX - temp hack until we check at compile time */
39
40 enum
41 {
42 SWF_BIG_ENDIAN,
43 SWF_LITTLE_ENDIAN
44 };
45
46 static int byteorder;
47
48 void checkByteOrder()
49 {
50 unsigned int x;
51 unsigned char *p;
52
53 x = 0x01020304;
54 p = (unsigned char *)&x;
55
56 if(*p == 1)
57 byteorder = SWF_BIG_ENDIAN;
58 else
59 byteorder = SWF_LITTLE_ENDIAN;
60 }
61
62
63 char *stringConcat(char *a, char *b)
64 {
65 if ( a != NULL )
66 {
67 if ( b != NULL )
68 {
69 a = (char*)realloc(a, strlen(a)+strlen(b)+1);
70 strcat(a, b);
71 free(b);
72 }
73
74 return a;
75 }
76 else
77 return b;
78 }
79
80 void bufferPatchLength(Buffer buffer, int back)
81 {
82 unsigned char *output = buffer->buffer;
83 int len = bufferLength(buffer);
84
85 output[len-back-1] = (back>>8) & 0xff;
86 output[len-back-2] = back & 0xff;
87 }
88
89
90 /* add len more bytes to length of the pushdata opcode pointed to by
91 buffer->pushloc */
92
93 void bufferPatchPushLength(Buffer buffer, int len)
94 {
95 int oldsize;
96
97 if(buffer->pushloc != NULL)
98 {
99 oldsize = (buffer->pushloc[0] & 0xff) | ((buffer->pushloc[1] & 0xff) << 8);
100 oldsize += len;
101 buffer->pushloc[0] = oldsize & 0xff;
102 buffer->pushloc[1] = (oldsize >> 8) & 0xff;
103 }
104 else
105 SWF_error("problem with bufferPatchPushLength\n");
106 }
107
108
109 static int useConstants = 1;
110 void Ming_useConstants(int flag)
111 { useConstants = flag;
112 }
113
114
115 int addConstant(const char *s)
116 {
117 int i;
118
119 for(i=0; i<nConstants; ++i)
120 {
121 if(strcmp(s, constants[i]) == 0)
122 return i;
123 }
124
125 /* Don't let constant pool biggern then allowed */
126 if ( sizeConstants+strlen(s)+1 > MAXCONSTANTPOOLSIZE ) return -1;
127
128 if(nConstants == maxConstants)
129 constants = (char **) realloc(constants, (maxConstants += 64) * sizeof(char *));
130 constants[nConstants] = strdup(s);
131 sizeConstants += (strlen(s)+1);
132 return nConstants++;
133 }
134
135 int bufferWriteConstants(Buffer out)
136 {
137 int i, len=2;
138
139 if(nConstants == 0)
140 return 0;
141
142 bufferWriteU8(out, SWFACTION_CONSTANTPOOL);
143 bufferWriteS16(out, 0); /* length */
144 bufferWriteS16(out, nConstants);
145
146 for(i=0; i<nConstants; ++i)
147 {
148 len += bufferWriteHardString(out,(byte*) constants[i], strlen(constants[i])+1);
149 free(constants[i]);
150 }
151
152 nConstants = 0;
153 sizeConstants = 0;
154 bufferPatchLength(out, len);
155
156 return len+3;
157 }
158
159 Buffer newBuffer()
160 {
161 Buffer out = (Buffer)malloc(BUFFER_SIZE);
162 memset(out, 0, BUFFER_SIZE);
163
164 out->buffer = (byte*)malloc(BUFFER_INCREMENT);
165 out->pos = out->buffer;
166 *(out->pos) = 0;
167 out->buffersize = out->free = BUFFER_INCREMENT;
168 out->pushloc = NULL;
169
170 return out;
171 }
172
173 void destroyBuffer(Buffer out)
174 {
175 free(out->buffer);
176 free(out);
177 }
178
179 int bufferLength(Buffer out)
180 {
181 if(out)
182 return (out->pos)-(out->buffer);
183 else
184 return 0;
185 }
186
187 /* make sure there's enough space for bytes bytes */
188 void bufferCheckSize(Buffer out, int bytes)
189 {
190 if(bytes > out->free)
191 {
192 int New = BUFFER_INCREMENT * ((bytes-out->free-1)/BUFFER_INCREMENT + 1);
193
194 int num = bufferLength(out); /* in case buffer gets displaced.. */
195 unsigned char *newbuf = (unsigned char*)realloc(out->buffer, out->buffersize+New);
196
197 if(newbuf != out->buffer)
198 {
199 int pushd;
200
201 if(out->pushloc)
202 pushd = out->pos - out->pushloc;
203
204 out->pos = newbuf+num;
205
206 if(out->pushloc)
207 out->pushloc = out->pos - pushd;
208 }
209
210 out->buffer = newbuf;
211 out->buffersize += New;
212 out->free += New;
213 }
214 }
215
216 int bufferWriteData(Buffer b, const byte *data, int length)
217 {
218 int i;
219
220 bufferCheckSize(b, length);
221
222 for(i=0; i<length; ++i)
223 bufferWriteU8(b, data[i]);
224
225 return length;
226 }
227
228 int bufferWriteBuffer(Buffer a, Buffer b)
229 {
230 if(!a)
231 return 0;
232
233 if(b)
234 return bufferWriteData(a, b->buffer, bufferLength(b));
235
236 return 0;
237 }
238
239 /* if a's last op and b's first op are both PUSHDATA, concat into one op */
240
241 int bufferWriteDataAndPush(Buffer a, Buffer b)
242 {
243 int i, pushd;
244
245 byte *data = b->buffer;
246 int length = b->pos - b->buffer;
247
248 if(a->pushloc && (b->buffer[0] == SWFACTION_PUSHDATA) && SWF_versionNum > 4)
249 {
250 pushd = (b->buffer[1] & 0xff) | ((b->buffer[2] & 0xff) << 8);
251 bufferPatchPushLength(a, pushd);
252 data += 3;
253 length -= 3;
254 }
255
256 if(b->pushloc)
257 pushd = b->pos - b->pushloc;
258
259 bufferCheckSize(a, length);
260
261 for(i=0; i<length; ++i)
262 bufferWriteU8(a, data[i]);
263
264 if(a->pushloc &&
265 (b->buffer[0] == SWFACTION_PUSHDATA) && (b->pushloc == b->buffer+1))
266 ; /* b is just one pushdata, so do nothing.. */
267 else if(b->pushloc)
268 a->pushloc = a->pos - pushd;
269 else
270 a->pushloc = 0;
271
272 return length;
273 }
274
275 int bufferConcat(Buffer a, Buffer b)
276 {
277 int len;
278
279 if(!a)
280 return 0;
281
282 if(b)
283 { len = bufferWriteDataAndPush(a, b);
284 destroyBuffer(b);
285 }
286
287 return len;
288 }
289
290 int bufferWriteOp(Buffer out, int data)
291 {
292 bufferWriteU8(out, data);
293 out->pushloc = NULL;
294
295 return 1;
296 }
297
298 int bufferWritePushOp(Buffer out)
299 {
300 bufferWriteU8(out, SWFACTION_PUSHDATA);
301 out->pushloc = out->pos;
302
303 return 1;
304 }
305
306 int bufferWriteU8(Buffer out, int data)
307 {
308 bufferCheckSize(out, 1);
309 *(out->pos) = data;
310 out->pos++;
311 out->free--;
312
313 return 1;
314 }
315
316 int bufferWriteS16(Buffer out, int data)
317 {
318 if(data < 0)
319 data = (1<<16)+data;
320
321 bufferWriteU8(out, data%256);
322 data >>= 8;
323 bufferWriteU8(out, data%256);
324
325 return 2;
326 }
327
328 int bufferWriteHardString(Buffer out, byte *string, int length)
329 {
330 int i;
331
332 for(i=0; i<length; ++i)
333 bufferWriteU8(out, string[i]);
334
335 return length;
336 }
337
338 int bufferWriteConstantString(Buffer out, byte *string, int length)
339 {
340 int n;
341
342 if(SWF_versionNum < 5)
343 return -1;
344
345 if(useConstants)
346 n = addConstant((char*) string);
347 else
348 n = -1;
349
350 if(n == -1)
351 {
352 bufferWriteU8(out, PUSH_STRING);
353 return bufferWriteHardString(out, string, length) + 1;
354 }
355 else if(n < 256)
356 {
357 bufferWriteU8(out, PUSH_CONSTANT);
358 return bufferWriteU8(out, n) + 1;
359 }
360 else
361 {
362 bufferWriteU8(out, PUSH_CONSTANT16);
363 return bufferWriteS16(out, n) + 1;
364 }
365 }
366
367 int bufferWriteString(Buffer out, byte *string, int length)
368 {
369 if(SWF_versionNum < 5)
370 {
371 bufferWritePushOp(out);
372 bufferWriteS16(out, length+1);
373 bufferWriteU8(out, PUSH_STRING);
374 bufferWriteHardString(out, string, length);
375
376 return 4 + length;
377 }
378 else
379 {
380 int l;
381
382 if(out->pushloc == NULL)
383 {
384 bufferWritePushOp(out);
385 bufferWriteS16(out, 0);
386 }
387
388 l = bufferWriteConstantString(out, string, length);
389
390 bufferPatchPushLength(out, l);
391 return l;
392 }
393 }
394
395 int bufferWriteInt(Buffer out, int i)
396 {
397 int len = 0;
398 unsigned char *p = (unsigned char *)&i;
399
400 if(out->pushloc == NULL || SWF_versionNum < 5)
401 {
402 len = 3;
403 bufferWritePushOp(out);
404 bufferWriteS16(out, 5);
405 }
406 else
407 bufferPatchPushLength(out, 5);
408
409 bufferWriteU8(out, PUSH_INT);
410
411 if(byteorder == SWF_LITTLE_ENDIAN)
412 {
413 bufferWriteU8(out, p[0]);
414 bufferWriteU8(out, p[1]);
415 bufferWriteU8(out, p[2]);
416 bufferWriteU8(out, p[3]);
417 }
418 else
419 {
420 bufferWriteU8(out, p[3]);
421 bufferWriteU8(out, p[2]);
422 bufferWriteU8(out, p[1]);
423 bufferWriteU8(out, p[0]);
424 }
425
426 return len + 5;
427 }
428
429 int bufferWriteDouble(Buffer out, double d)
430 {
431 int len = 0;
432 unsigned char *p = (unsigned char *)&d;
433
434 if(out->pushloc == NULL || SWF_versionNum < 5)
435 {
436 len = 3;
437 bufferWritePushOp(out);
438 bufferWriteS16(out, 9);
439 }
440 else
441 bufferPatchPushLength(out, 5);
442
443 bufferWriteU8(out, PUSH_DOUBLE);
444
445 if(byteorder == SWF_LITTLE_ENDIAN)
446 {
447 bufferWriteU8(out, p[4]);
448 bufferWriteU8(out, p[5]);
449 bufferWriteU8(out, p[6]);
450 bufferWriteU8(out, p[7]);
451 bufferWriteU8(out, p[0]);
452 bufferWriteU8(out, p[1]);
453 bufferWriteU8(out, p[2]);
454 bufferWriteU8(out, p[3]);
455 }
456 else
457 {
458 bufferWriteU8(out, p[3]);
459 bufferWriteU8(out, p[2]);
460 bufferWriteU8(out, p[1]);
461 bufferWriteU8(out, p[0]);
462 bufferWriteU8(out, p[7]);
463 bufferWriteU8(out, p[6]);
464 bufferWriteU8(out, p[5]);
465 bufferWriteU8(out, p[4]);
466 }
467
468 return len + 9;
469 }
470
471 int bufferWriteNull(Buffer out)
472 {
473 int len = 0;
474
475 if(out->pushloc == NULL || SWF_versionNum < 5)
476 {
477 len = 3;
478 bufferWritePushOp(out);
479 bufferWriteS16(out, 1);
480 }
481 else
482 bufferPatchPushLength(out, 1);
483
484 bufferWriteU8(out, PUSH_NULL);
485
486 return len + 1;
487 }
488
489 int bufferWriteBoolean(Buffer out, int val)
490 {
491 int len = 0;
492
493 if(out->pushloc == NULL || SWF_versionNum < 5)
494 {
495 len = 3;
496 bufferWritePushOp(out);
497 bufferWriteS16(out, 2);
498 }
499 else
500 bufferPatchPushLength(out, 2);
501
502 bufferWriteU8(out, PUSH_BOOLEAN);
503 bufferWriteU8(out, val ? 1 : 0);
504
505 return len + 2;
506 }
507
508 int bufferWriteRegister(Buffer out, int num)
509 {
510 int len = 0;
511
512 if(out->pushloc == NULL || SWF_versionNum < 5)
513 {
514 len = 3;
515 bufferWritePushOp(out);
516 bufferWriteS16(out, 2);
517 }
518 else
519 bufferPatchPushLength(out, 2);
520
521 bufferWriteU8(out, PUSH_REGISTER);
522 bufferWriteU8(out, num);
523
524 return len + 2;
525 }
526
527 int bufferWriteSetRegister(Buffer out, int num)
528 {
529 bufferWriteU8(out, SWFACTION_SETREGISTER);
530 bufferWriteS16(out, 1);
531 bufferWriteU8(out, num);
532 return 4;
533 }
534
535 void lower(char *s)
536 {
537 while(*s)
538 {
539 *s = tolower(*s);
540 ++s;
541 }
542 }
543
544 /* this code will eventually help to pop extra values off the
545 stack and make sure that continue and break address the proper
546 context
547 */
548 static enum ctx *ctx_stack = {0};
549 static int ctx_count = {0}, ctx_len = {0};
550 void addctx(enum ctx val)
551 { if(ctx_count >= ctx_len)
552 ctx_stack = (enum ctx*) realloc(ctx_stack, (ctx_len += 10) * sizeof(enum ctx));
553 ctx_stack[ctx_count++] = val;
554 }
555 void delctx(enum ctx val)
556 { if(ctx_count <= 0 || ctx_stack[--ctx_count] != val)
557 SWF_error("consistency check in delctx");
558 }
559
560 int chkctx(enum ctx val)
561 { int n, ret = 0;
562 switch(val)
563 { case CTX_FUNCTION:
564 for(n = ctx_count ; --n >= 0 ; )
565 switch(ctx_stack[n])
566 { case CTX_SWITCH:
567 case CTX_FOR_IN:
568 ret++;
569 break;
570 case CTX_FUNCTION:
571 return ret;
572 default: ; /* computers are stupid */
573 }
574 return -1;
575 case CTX_BREAK:
576 for(n = ctx_count ; --n >= 0 ; )
577 switch(ctx_stack[n])
578 { case CTX_SWITCH:
579 case CTX_LOOP:
580 return 0;
581 case CTX_FOR_IN:
582 return 1;
583 case CTX_FUNCTION:
584 return -1;
585 default: ; /* computers are stupid */
586 }
587 case CTX_CONTINUE:
588 for(n = ctx_count ; --n >= 0 ; )
589 switch(ctx_stack[n])
590 { case CTX_LOOP:
591 case CTX_FOR_IN:
592 return 0;
593 case CTX_FUNCTION:
594 return -1;
595 default: ; /* computers are stupid */
596 }
597 default: ; /* computers are stupid */
598 }
599 return 0;
600 }
601
602 /* replace MAGIC_CONTINUE_NUMBER and MAGIC_BREAK_NUMBER with jumps to
603 head or tail, respectively */
604 /* jump offset is relative to end of jump instruction */
605 /* I can't believe this actually worked */
606
607 void bufferResolveJumps(Buffer out)
608 {
609 byte *p = out->buffer;
610 int l, target;
611
612 while(p < out->pos)
613 {
614 if(*p & 0x80) /* then it's a multibyte instruction */
615 {
616 if(*p == SWFACTION_BRANCHALWAYS)
617 {
618 p += 3; /* plus instruction plus two-byte length */
619
620 if(*p == MAGIC_CONTINUE_NUMBER_LO &&
621 *(p+1) == MAGIC_CONTINUE_NUMBER_HI)
622 {
623 target = out->buffer - (p+2);
624 *p = target & 0xff;
625 *(p+1) = (target>>8) & 0xff;
626 }
627 else if(*p == MAGIC_BREAK_NUMBER_LO &&
628 *(p+1) == MAGIC_BREAK_NUMBER_HI)
629 {
630 target = out->pos - (p+2);
631 *p = target & 0xff;
632 *(p+1) = (target>>8) & 0xff;
633 }
634
635 p += 2;
636 }
637 else
638 {
639 ++p;
640 l = *p;
641 ++p;
642 l += *p<<8;
643 ++p;
644
645 p += l;
646 }
647 }
648 else
649 ++p;
650 }
651 }
652
653 // handle SWITCH statement
654
655 void bufferResolveSwitch(Buffer buffer, struct switchcases *slp)
656 { struct switchcase *scp;
657 int n, len;
658 unsigned char *output;
659
660 len = bufferLength(buffer);
661 for(n = 0, scp = slp->list ; n < slp->count ; n++, scp++)
662 { scp->actlen = bufferLength(scp->action);
663 if((n < slp->count-1))
664 scp->actlen += 5;
665 if(scp->cond)
666 { scp->condlen = bufferLength(scp->cond) + 8;
667 bufferWriteOp(buffer, SWFACTION_DUP);
668 bufferConcat(buffer, scp->cond);
669 bufferWriteOp(buffer, SWFACTION_NEWEQUALS);
670 bufferWriteOp(buffer, SWFACTION_LOGICALNOT);
671 bufferWriteOp(buffer, SWFACTION_BRANCHIFTRUE);
672 bufferWriteS16(buffer, 2);
673 bufferWriteS16(buffer, scp->actlen);
674 }
675 else
676 scp->condlen = 0;
677 bufferConcat(buffer, scp->action);
678 bufferWriteOp(buffer, SWFACTION_BRANCHALWAYS);
679 bufferWriteS16(buffer, 2);
680 bufferWriteS16(buffer, scp->isbreak ? MAGIC_BREAK_NUMBER : 0);
681 if(!scp->cond)
682 { slp->count = n+1;
683 break;
684 }
685 }
686 for(n = 0, scp = slp->list ; n < slp->count ; n++, scp++)
687 { len += scp->condlen;
688 output = buffer->buffer + len;
689 if((n < slp->count-1) && !scp->isbreak)
690 { output[scp->actlen-2] = (scp+1)->condlen & 0xff;
691 output[scp->actlen-1] = (scp+1)->condlen >> 8;
692 }
693 len += scp->actlen;
694 }
695 }
696
697 int lookupSetProperty(char *string)
698 {
699 lower(string);
700
701 if(strcmp(string,"x")==0) return 0x0000;
702 if(strcmp(string,"y")==0) return 0x3f80;
703 if(strcmp(string,"xscale")==0) return 0x4000;
704 if(strcmp(string,"yscale")==0) return 0x4040;
705 if(strcmp(string,"alpha")==0) return 0x40c0;
706 if(strcmp(string,"visible")==0) return 0x40e0;
707 if(strcmp(string,"rotation")==0) return 0x4120;
708 if(strcmp(string,"name")==0) return 0x4140;
709 if(strcmp(string,"quality")==0) return 0x4180;
710 if(strcmp(string,"focusrect")==0) return 0x4188;
711 if(strcmp(string,"soundbuftime")==0) return 0x4190;
712
713 SWF_error("No such property: %s\n", string);
714 return -1;
715 }
716
717 int bufferWriteSetProperty(Buffer out, char *string)
718 {
719 int property = lookupSetProperty(string);
720
721 bufferWriteU8(out, SWFACTION_PUSHDATA);
722 bufferWriteS16(out, 5);
723 bufferWriteU8(out, PUSH_PROPERTY);
724 bufferWriteS16(out, 0);
725 bufferWriteS16(out, property);
726
727 return 8;
728 }
729
730 int bufferWriteWTHITProperty(Buffer out)
731 {
732 bufferWriteU8(out, SWFACTION_PUSHDATA);
733 bufferWriteS16(out, 5);
734 bufferWriteU8(out, PUSH_PROPERTY);
735 bufferWriteS16(out, 0);
736 bufferWriteS16(out, 0x4680);
737
738 return 8;
739 }
740
741 const char *lookupGetProperty(char *string)
742 {
743 lower(string);
744
745 if(strcmp(string,"x")==0) return "0";
746 if(strcmp(string,"y")==0) return "1";
747 if(strcmp(string,"xscale")==0) return "2";
748 if(strcmp(string,"yscale")==0) return "3";
749 if(strcmp(string,"currentframe")==0) return "4";
750 if(strcmp(string,"totalframes")==0) return "5";
751 if(strcmp(string,"alpha")==0) return "6";
752 if(strcmp(string,"visible")==0) return "7";
753 if(strcmp(string,"width")==0) return "8";
754 if(strcmp(string,"height")==0) return "9";
755 if(strcmp(string,"rotation")==0) return "10";
756 if(strcmp(string,"target")==0) return "11";
757 if(strcmp(string,"framesloaded")==0) return "12";
758 if(strcmp(string,"name")==0) return "13";
759 if(strcmp(string,"droptarget")==0) return "14";
760 if(strcmp(string,"url")==0) return "15";
761 if(strcmp(string,"quality")==0) return "16";
762 if(strcmp(string,"focusrect")==0) return "17";
763 if(strcmp(string,"soundbuftime")==0) return "18";
764
765 SWF_error("No such property: %s\n", string);
766 return "";
767 }
768
769 int bufferWriteGetProperty(Buffer out, char *string)
770 {
771 const char *property = lookupGetProperty(string);
772
773 bufferWriteU8(out, SWFACTION_PUSHDATA);
774 bufferWriteS16(out, strlen(property)+2);
775 bufferWriteU8(out, PUSH_STRING);
776
777 return 4 + bufferWriteData(out, (byte*) property, strlen(property)+1);
778 }
779
780
781 /*
782 * Local variables:
783 * tab-width: 2
784 * c-basic-offset: 2
785 * End:
786 */
SWFTools is a collection of utilities for working with Adobe Flash files