regenerated
[swftools.git] / lib / action / compile.c
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  */