swfmill 0.0.1

data/ext/swfmill/src/SWFIdItems.h

@@ -0,0 +1,16 @@
+#ifndef SWF_IDITEMS_H
+#define SWF_IDITEMS_H
+
+#include <SWFIdItem.h>
+
+namespace SWF {
+
+class StackItem : public IdItem<StackItem> {};
+class Style : public IdItem<Style> {};
+class NamespaceConstant : public IdItem<NamespaceConstant> {};
+class MultinameConstant : public IdItem<MultinameConstant> {};
+class OpCode : public IdItem<OpCode> {};
+
+}
+#endif
+

data/ext/swfmill/src/SWFItem.cpp

@@ -0,0 +1,235 @@
+#include "SWFItem.h"
+#include <cstring>
+#include <cctype>
+#include "base64.h"
+#include <sys/types.h>
+
+namespace SWF {
+
+// ------------ utility functions
+	
+int swf_get_bits_needed_for_uint( uint64_t value ) {
+	int i=0;
+	while( value > 0 ) {
+		value >>= 1;
+		i++;
+	}
+	return i;
+}
+
+int swf_get_bits_needed_for_int( int64_t value ) {
+	if( value < 0 )
+		/* XXX one more than necessary if num = -2^n */
+		return swf_get_bits_needed_for_uint( -value ) + 1;
+	else if ( value > 0 )
+		return swf_get_bits_needed_for_uint( value ) + 1;
+	else
+		return 0;
+}
+
+int swf_get_bits_needed_for_fp( double value ) {
+	return swf_get_bits_needed_for_int( (int64_t)(value * 65536.0) );
+}
+	
+int SWFBitsNeeded( int32_t value, bool is_signed ) {
+	if( is_signed ) 
+		return swf_get_bits_needed_for_int( value );
+	else
+		return swf_get_bits_needed_for_uint( value );
+	/*
+	long cnt;
+	if( is_signed ) {
+		if(value < 0) {
+			// a special case
+			if(value == -1) {
+				return 1;
+			}
+			cnt = 33;
+			do {
+				cnt--;
+				value *= 2;
+			} while(value < 0);
+			if( value == 0 ) return cnt+1;
+		}
+		else {
+			// a special case
+			if(value == 0) {
+				return 1;
+			}
+			cnt = 33;
+			do {
+				cnt--;
+				value *= 2;
+			} while(value > 0);
+			if( value == 0 ) return cnt+1;
+		}
+	} else {
+	if( value < 0 ) {
+		printf("ERROR: unsigned, but <0? %s:%i\n", __FILE__, __LINE__);
+		abort();
+	}
+		// a special case
+		if(value == 0) {
+			return 1;
+		}
+		cnt = 32;
+		while((long) value > 0) {
+			cnt--;
+			value *= 2;
+		}
+		if( value == 0 ) return cnt+1;
+	}
+	return cnt;
+	*/
+}
+
+long SWFMaxBitsNeeded( bool is_signed, int how_many, ... ) {
+	long bits = 0;
+	va_list ap;
+	int n;
+	va_start( ap, how_many );
+	
+	for( int i=0; i<how_many; i++ ) {
+		int b = SWFBitsNeeded( va_arg( ap, int ), is_signed );
+		if( b > bits ) bits = b;
+	}
+	
+	va_end( ap );
+	return bits;
+}
+
+Item::Item() {
+	file_offset = -1;
+	cached_size = -1;
+}
+
+size_t Item::getSize( Context *ctx, int start_at ) {
+	if( cached_size == -1 ) {
+		cached_size = calcSize( ctx, start_at );
+	}
+	return cached_size;
+}
+
+int Item::getHeaderSize( int size ) {
+	return 0;
+}
+	
+void Item::writeHeader( Writer *w, Context *ctx, size_t len ) {
+}
+
+
+
+Rest::Rest() {
+	size = 0;
+	data = NULL;
+}
+
+Rest::~Rest() {
+	delete[] data;
+}
+
+bool Rest::parse( Reader *r, int end, Context *ctx ) {
+	file_offset = r->getPosition();
+
+	size = end - r->getPosition();
+	if( size > 0 ) {
+		data = new unsigned char[size];
+		r->getData( data, size );
+	}
+
+	return r->getError() == SWFR_OK;
+}
+
+void Rest::dump( int indent, Context *ctx ) {
+	for( int i=0; i<indent; i++ ) printf("  ");
+	printf("Rest (length %i)\n", size);
+	if( size && data != NULL ) {
+		int i=0;
+		while( i<size ) {
+			for( int in=0; in<indent+1; in++ ) printf("  ");
+			for( int n=0; n<8 && i<size; n++ ) {
+				printf(" %02X",  data[i] );
+				i++;
+			}
+			printf("\n");
+		}
+	}
+}
+
+size_t Rest::calcSize( Context *ctx, int start_at ) {
+	int r = start_at;
+	r += size * 8;
+	r += Item::getHeaderSize(r-start_at);
+	return r-start_at;
+}
+
+void Rest::write( Writer *w, Context *ctx ) {
+	Item::writeHeader( w, ctx, 0 );
+	
+	if( size && data ) {
+		w->putData( data, size );
+	}
+}
+
+#define TMP_STRLEN 0xFF
+void Rest::writeXML( xmlNodePtr xml, Context *ctx ) {
+	char tmp[TMP_STRLEN];
+	xmlNodePtr node = xml;
+	
+//	node = xmlNewChild( node, NULL, (const xmlChar *)"Rest", NULL );
+	{
+		if( size && data ) {
+			char *tmp_data = (char *)data;
+			int sz = size;
+			char *tmpstr = new char[ (sz * 3) ];
+			
+			int l = base64_encode( tmpstr, tmp_data, sz );
+			if( l > 0 ) {
+				tmpstr[l] = 0;
+				xmlNewTextChild( node, NULL, (const xmlChar *)"data", (const xmlChar *)tmpstr );
+			}
+			delete[] tmpstr;
+		}
+	}
+}
+
+void Rest::parseXML( xmlNodePtr node, Context *ctx ) {
+	data = NULL;
+	size = 0;
+
+	xmlChar *xmld = xmlNodeGetContent( node );
+	char *d = (char *)xmld;
+	if( d ) {
+		// unsure if this is neccessary
+		for( int i=strlen(d)-1; i>0 && isspace(d[i]); i-- ) d[i]=0;
+		while( isspace(d[0]) ) d++;
+		int l = strlen(d);
+		char *dst = new char[ l ];
+		int lout = base64_decode( dst, (char*)d, l );
+		if( lout > 0 ) {
+			size = lout;
+			data = new unsigned char[ lout ];
+			memcpy( data, dst, lout );
+		}
+		delete[] dst;
+		xmlFree( xmld );
+	} 
+}
+
+void Rest::getdata( unsigned char **d, int *s ) {
+	*d = data;
+	*s = size;
+}
+
+void Rest::setdata( unsigned char *d, int s ) {
+	delete[] data;
+	data = NULL;
+	size = s;
+	
+	if( size ) {
+		data = new unsigned char[ size ];
+		memcpy( data, d, size );
+	}
+}
+
+}

data/ext/swfmill/src/SWFItem.h

@@ -0,0 +1,60 @@
+#ifndef SWF_ITEM_H
+#define SWF_ITEM_H
+
+#include <SWFReader.h>
+#include <SWFWriter.h>
+#include <libxml/tree.h>
+
+namespace SWF {
+
+class Context;
+	
+int SWFBitsNeeded( int32_t value, bool is_signed = false );
+long SWFMaxBitsNeeded( bool is_signed, int how_many, ... );
+
+class Item {
+	public:
+		Item();
+		virtual ~Item() {}
+	
+		virtual bool parse( Reader *r, int end, Context *ctx ) = 0;
+		virtual void dump( int indent, Context *ctx ) = 0;
+		virtual size_t calcSize( Context *ctx, int start_at ) = 0;
+		virtual void write( Writer *r, Context *ctx ) = 0;
+	
+		virtual void writeXML( xmlNodePtr xml, Context *ctx ) = 0;
+		virtual void parseXML( xmlNodePtr xml, Context *ctx ) = 0;
+			
+		// wont touch the context if size is cached.
+		size_t getSize( Context *ctx, int start_at );
+	
+	protected:
+		int getHeaderSize( int size );
+		void writeHeader( Writer *w, Context *ctx, size_t len );
+	
+		int file_offset; // bytes after header for SWF, line for XML (NYI)
+		int cached_size; // cached size
+};
+	
+// to save the rest of a tag as binary data...
+class Rest : public Item {
+	public:
+		Rest();
+		virtual ~Rest();
+		virtual bool parse( Reader *r, int end, Context *ctx );
+		virtual void dump( int indent, Context *ctx );
+		virtual size_t calcSize( Context *ctx, int start_at );
+		virtual void write( Writer *w, Context *ctx );
+		virtual void writeXML( xmlNodePtr node, Context *ctx );
+		virtual void parseXML( xmlNodePtr node, Context *ctx );
+	
+		void getdata( unsigned char **data, int *size );
+		void setdata( unsigned char *data, int size );
+	
+	protected:
+		int size;
+		unsigned char *data;
+};
+	
+}
+#endif

data/ext/swfmill/src/SWFList.h

@@ -0,0 +1,179 @@
+#ifndef F_List_H
+#define F_List_H
+
+#include <cstdio>
+#define WARNING printf
+
+namespace SWF {
+
+template <class T> class ListItem;
+
+/*
+	a simple (likely non-threadsafe) LinkedList
+*/
+
+template <class T>
+class List {
+	public:
+		List( bool ownership = true )
+				: mOwnership( ownership ) {
+				mFirst = mLast = NULL;
+			}
+		~List() {
+				ListItem<T> *item = mFirst, *next;
+				if( mOwnership ) {
+					while( item ) {
+						if( item->data() ) delete item->data();
+						next = item->next();
+						delete item;
+						item = next;
+					}
+				} else {
+					while( item ) {
+						next = item->next();
+						delete item;
+						item = next;
+					}
+				}
+			}
+			
+		ListItem<T> *append( T *data, void *user_data = NULL ) {
+				if( !mLast ) {
+					if( !mFirst ) {
+						return mFirst = mLast = new ListItem<T>( data, NULL, user_data );
+					} else {
+						WARNING("Linked List has First but no Last item\n");
+						return NULL;
+					}
+				} else {
+					return mLast = new ListItem<T>( data, mLast, user_data );
+				}
+			}
+
+		ListItem<T> *prepend( T *data, void *user_data = NULL ) {
+				if( !mFirst ) {
+					return mFirst = mLast = new ListItem<T>( data, NULL, user_data );
+				} else {
+					ListItem<T> *item = new ListItem<T>( data, NULL, user_data );
+					item->mNext = mFirst;
+					mFirst->mPrevious = item;
+					return mFirst = item;
+				}
+			}
+
+		ListItem<T> *prepend2( T *data, void *user_data = NULL ) {
+				if( !mFirst ) {
+					return mFirst = mLast = new ListItem<T>( data, NULL, user_data );
+				} else {
+					return new ListItem<T>( data, mFirst, user_data );
+				}
+			}
+			
+		T* remove( ListItem<T> *item ) {
+				item->remove( this );
+				T *ret = item->data();
+				if( mOwnership && item->data() ) {
+					delete item->data();
+					ret = NULL;
+				}
+				delete item;
+				return ret;
+			}
+
+		void moveToLast( ListItem<T> *item ) {
+				if( item == mLast ) return;
+				item->remove( this );
+				item->mPrevious = mLast;
+				if( mLast ) {
+					mLast->mNext = item;
+				}
+				mLast = item;
+				if( !mFirst ) mFirst = item;
+			}
+			
+		ListItem<T> *first() { return mFirst; };
+		ListItem<T> *last() { return mLast; };
+
+		friend class ListItem<T>;
+		
+		int size() {
+			if (mFirst == NULL) return 0;
+			if (mFirst == mLast) return 1;
+			
+			int count = 1;
+			ListItem<T> *item = mFirst;
+			while(item != mLast) {
+				count++;
+				item = item->next();
+			}
+			
+			return count;
+		}
+			
+	protected:
+		ListItem<T> *mFirst;
+		ListItem<T> *mLast;
+		bool mOwnership;
+};
+
+template <class T>
+class ListItem {
+	public:
+		ListItem( T *data, ListItem* insertAfter = NULL, void *user_data = NULL ) {
+				mData = data;
+				mPrevious = insertAfter;
+				mNext = insertAfter ? insertAfter->replaceNext( this ) : NULL;
+				if( mNext ) mNext->mPrevious = this;
+				mUserData = user_data;
+			}
+		
+		ListItem *replaceNext( ListItem *next ) {
+				ListItem *ret = mNext;
+				mNext = next;
+				return ret;
+			}
+			
+		void remove( List<T> *list ) {
+				if( !mPrevious ) list->mFirst = mNext;
+				else mPrevious->mNext = mNext;
+				if( !mNext ) list->mLast = mPrevious;
+				else mNext->mPrevious = mPrevious;
+				mPrevious = mNext = NULL;
+			}
+			
+		ListItem *next() {
+				return( mNext );
+			}
+
+		ListItem *previous() {
+				return( mPrevious );
+			}
+
+		T* data() {
+				return( mData );
+			}
+
+		void* UserData() {
+				return( mUserData );
+			}
+			
+		bool isLast() {
+				return( mNext == 0 );
+			}
+		bool isFirst() {
+				return( mPrevious == 0 );
+			}
+
+		friend class List<T>;
+			
+	protected:
+		ListItem *mPrevious;
+		ListItem *mNext;
+		T *mData;
+		void *mUserData;
+};
+
+
+}
+
+#endif