swfmill 0.0.2 → 0.0.3

data/ext/libb64/include/b64/encode.h

@@ -0,0 +1,77 @@
+// :mode=c++:
+/*
+encode.h - c++ wrapper for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+#ifndef BASE64_ENCODE_H
+#define BASE64_ENCODE_H
+
+#include <iostream>
+
+namespace base64
+{
+	extern "C" 
+	{
+		#include "cencode.h"
+	}
+
+	struct encoder
+	{
+		base64_encodestate _state;
+		int _buffersize;
+
+		encoder(int buffersize_in = BUFFERSIZE)
+		: _buffersize(buffersize_in)
+		{}
+
+		int encode(char value_in)
+		{
+			return base64_encode_value(value_in);
+		}
+
+		int encode(const char* code_in, const int length_in, char* plaintext_out)
+		{
+			return base64_encode_block(code_in, length_in, plaintext_out, &_state);
+		}
+
+		int encode_end(char* plaintext_out)
+		{
+			return base64_encode_blockend(plaintext_out, &_state);
+		}
+
+		void encode(std::istream& istream_in, std::ostream& ostream_in)
+		{
+			base64_init_encodestate(&_state);
+			//
+			const int N = _buffersize;
+			char* plaintext = new char[N];
+			char* code = new char[2*N];
+			int plainlength;
+			int codelength;
+
+			do
+			{
+				istream_in.read(plaintext, N);
+				plainlength = istream_in.gcount();
+				//
+				codelength = encode(plaintext, plainlength, code);
+				ostream_in.write(code, codelength);
+			}
+			while (istream_in.good() && plainlength > 0);
+
+			codelength = encode_end(code);
+			ostream_in.write(code, codelength);
+			//
+			base64_init_encodestate(&_state);
+
+			delete [] code;
+			delete [] plaintext;
+		}
+	};
+
+} // namespace base64
+
+#endif // BASE64_ENCODE_H
+

data/ext/libb64/src/Makefile

@@ -0,0 +1,43 @@
+LIBRARIES = libb64.a
+
+# Build flags (uncomment one)
+#############################
+# Release build flags
+CFLAGS += -fPIC -O3
+#############################
+# Debug build flags
+#CFLAGS += -g
+#############################
+
+SOURCES = cdecode.c  cencode.c
+
+TARGETS = $(LIBRARIES)
+
+LINK.o = gcc
+
+CFLAGS += -Werror -pedantic
+CFLAGS += -I../include
+
+vpath %.h ../include/b64
+
+.PHONY : clean
+
+all: $(TARGETS) #strip
+
+libb64.a: cencode.o cdecode.o
+	$(AR) $(ARFLAGS) $@ $^
+
+strip:
+	strip $(BINARIES) *.exe
+
+clean:
+	rm -f *.exe* *.o $(TARGETS) *.bak *~
+
+distclean: clean
+	rm -f depend
+
+depend: $(SOURCES)
+	makedepend -f- $(CFLAGS) $(SOURCES) 2> /dev/null 1> depend
+
+-include depend
+

data/ext/libb64/src/cdecode.c

@@ -0,0 +1,88 @@
+/*
+cdecoder.c - c source to a base64 decoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include <b64/cdecode.h>
+
+int base64_decode_value(char value_in)
+{
+	static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
+	static const char decoding_size = sizeof(decoding);
+	value_in -= 43;
+	if (value_in < 0 || value_in > decoding_size) return -1;
+	return decoding[(int)value_in];
+}
+
+void base64_init_decodestate(base64_decodestate* state_in)
+{
+	state_in->step = step_a;
+	state_in->plainchar = 0;
+}
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
+{
+	const char* codechar = code_in;
+	char* plainchar = plaintext_out;
+	char fragment;
+	
+	*plainchar = state_in->plainchar;
+	
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_a:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_a;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				fragment = (char)base64_decode_value(*codechar++);
+			} while (fragment < 0);
+			*plainchar    = (fragment & 0x03f) << 2;
+	case step_b:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_b;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				fragment = (char)base64_decode_value(*codechar++);
+			} while (fragment < 0);
+			*plainchar++ |= (fragment & 0x030) >> 4;
+			*plainchar    = (fragment & 0x00f) << 4;
+	case step_c:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_c;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				fragment = (char)base64_decode_value(*codechar++);
+			} while (fragment < 0);
+			*plainchar++ |= (fragment & 0x03c) >> 2;
+			*plainchar    = (fragment & 0x003) << 6;
+	case step_d:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_d;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				fragment = (char)base64_decode_value(*codechar++);
+			} while (fragment < 0);
+			*plainchar++   |= (fragment & 0x03f);
+		}
+	}
+	/* control should not reach here */
+	return plainchar - plaintext_out;
+}
+

data/ext/libb64/src/cencode.c

@@ -0,0 +1,109 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include <b64/cencode.h>
+
+const int CHARS_PER_LINE = 72;
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+	state_in->step = step_A;
+	state_in->result = 0;
+	state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+	static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	if (value_in > 63) return '=';
+	return encoding[(int)value_in];
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+	const char* plainchar = plaintext_in;
+	const char* const plaintextend = plaintext_in + length_in;
+	char* codechar = code_out;
+	char result;
+	char fragment;
+	
+	result = state_in->result;
+	
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_A:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_A;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result = (fragment & 0x0fc) >> 2;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x003) << 4;
+	case step_B:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_B;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0f0) >> 4;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x00f) << 2;
+	case step_C:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_C;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0c0) >> 6;
+			*codechar++ = base64_encode_value(result);
+			result  = (fragment & 0x03f) >> 0;
+			*codechar++ = base64_encode_value(result);
+			
+			++(state_in->stepcount);
+			if (state_in->stepcount == CHARS_PER_LINE/4)
+			{
+				*codechar++ = '\n';
+				state_in->stepcount = 0;
+			}
+		}
+	}
+	/* control should not reach here */
+	return codechar - code_out;
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+	char* codechar = code_out;
+	
+	switch (state_in->step)
+	{
+	case step_B:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		*codechar++ = '=';
+		break;
+	case step_C:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		break;
+	case step_A:
+		break;
+	}
+	*codechar++ = '\n';
+	
+	return codechar - code_out;
+}
+

data/ext/swfmill/src/SWFItem.cpp

@@ -103,12 +103,14 @@ Item::Item() {
 	cached_size = -1;
 }
 
+#if 0
 size_t Item::getSize( Context *ctx, int start_at ) {
 	if( cached_size == -1 ) {
 		cached_size = calcSize( ctx, start_at );
 	}
 	return cached_size;
 }
+#endif
 
 int Item::getHeaderSize( int size ) {
 	return 0;

data/ext/swfmill/src/SWFItem.h

@@ -26,8 +26,13 @@ class Item {
 		virtual void parseXML( xmlNodePtr xml, Context *ctx ) = 0;
 			
 		// wont touch the context if size is cached.
-		size_t getSize( Context *ctx, int start_at );
-	
+		size_t getSize( Context *ctx, int start_at ) {
+			if( cached_size == -1 ) {
+				cached_size = calcSize( ctx, start_at );
+			}
+			return cached_size;
+		}
+
 	protected:
 		int getHeaderSize( int size );
 		void writeHeader( Writer *w, Context *ctx, size_t len );

data/ext/swfmill/src/swfmill.cpp

@@ -341,8 +341,8 @@ fail:
 void swfmill_create_library( xmlNodePtr lib, const char *filename );
 
 void swfmill_create_library_dir( xmlNodePtr lib, const char *dir ) {
-	char tmp[256];
-	
+	char tmp[1024];
+
 	struct dirent *e;
 	DIR *d = opendir( dir );
 	if( d == NULL ) return;

data/ext/swfmill_ext.cc

@@ -1,6 +1,7 @@
 #include "ruby.h"
 #include "swfmill_ext_to_xml.h"
 #include "swfmill_ext_to_swf.h"
+#include <libxml/xmlmemory.h>
 
 VALUE rb_mSwfmill;
 VALUE rb_eSwfmill_Error;
@@ -8,8 +9,19 @@ VALUE rb_eSwfmill_EOFError;
 
 extern "C" {
 
+static void
+init_xml_memory()
+{
+    xmlMemSetup((xmlFreeFunc)ruby_xfree,
+                (xmlMallocFunc)ruby_xmalloc,
+                (xmlReallocFunc)ruby_xrealloc,
+                strdup);
+}
+
 void Init_swfmill_ext(void)
 {
+    init_xml_memory();
+
     rb_mSwfmill = rb_define_module("Swfmill");
     rb_eSwfmill_Error = rb_define_class_under(rb_mSwfmill, "Error", rb_eStandardError);
     rb_eSwfmill_EOFError = rb_define_class_under(rb_mSwfmill, "EOFError", rb_eStandardError);

data/ext/swfmill_ext_to_swf.cc

@@ -51,6 +51,8 @@ sts_free(swfmill_to_swf * const sts)
 
         delete sts->context;
         sts->context = NULL;
+
+        xfree(sts);
     }
 }
 

data/ext/swfmill_ext_to_xml.cc

@@ -35,6 +35,8 @@ stx_free(swfmill_to_xml * const stx)
         stx->header = NULL;
         delete stx->context;
         stx->context = NULL;
+
+        xfree(stx);
     }
 }
 
@@ -162,15 +164,6 @@ stx_parse(swfmill_to_xml* const stx)
     return true;
 }
 
-static void
-stx_init_xml_memory()
-{
-    xmlMemSetup((xmlFreeFunc)ruby_xfree,
-                (xmlMallocFunc)ruby_xmalloc,
-                (xmlReallocFunc)ruby_xrealloc,
-                strdup);
-}
-
 static void
 stx_set_version_proparty(const swfmill_to_xml* const stx, xmlNodePtr root)
 {
@@ -220,7 +213,6 @@ stx_to_string(swfmill_to_xml* const stx)
     VALUE       xml = Qnil;
     xmlDocPtr   doc;
     xmlNodePtr root;
-    stx_init_xml_memory();
 
     doc  = xmlNewDoc((const xmlChar*)"1.0");
     root = doc->xmlRootNode = xmlNewDocNode(doc, NULL, (const xmlChar*)"swf", NULL);

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: swfmill
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - miyucy
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-09 00:00:00 +09:00
+date: 2010-09-17 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,10 +52,32 @@ files:
 - Rakefile
 - VERSION
 - ext/.gitignore
+- ext/base64.c
 - ext/buffer.h
 - ext/deflate.h
 - ext/extconf.rb
 - ext/inflate.h
+- ext/libb64/AUTHORS
+- ext/libb64/BENCHMARKS
+- ext/libb64/CHANGELOG
+- ext/libb64/INSTALL
+- ext/libb64/LICENSE
+- ext/libb64/Makefile
+- ext/libb64/README
+- ext/libb64/TODO
+- ext/libb64/base64/Makefile
+- ext/libb64/base64/VisualStudioProject/Makefile
+- ext/libb64/base64/VisualStudioProject/base64.sln
+- ext/libb64/base64/VisualStudioProject/base64.vcxproj
+- ext/libb64/base64/VisualStudioProject/base64.vcxproj.filters
+- ext/libb64/base64/base64.cc
+- ext/libb64/include/b64/cdecode.h
+- ext/libb64/include/b64/cencode.h
+- ext/libb64/include/b64/decode.h
+- ext/libb64/include/b64/encode.h
+- ext/libb64/src/Makefile
+- ext/libb64/src/cdecode.c
+- ext/libb64/src/cencode.c
 - ext/swfmill/.gitignore
 - ext/swfmill/AUTHORS
 - ext/swfmill/COPYING