gameswf_action.cpp

一个开源的Flash 播放器,可以在Windows/Linux 上运行

// gameswf_action.cpp	-- Thatcher Ulrich <[e-mail]> 2003

// This source code has been donated to the Public Domain.  Do
// whatever you want with it.

// Implementation and helpers for SWF actions.


#include "gameswf_action.h"
#include "gameswf_impl.h"
#include "gameswf_log.h"
#include "gameswf_stream.h"
#include "base/tu_random.h"

#include "gameswf_string.h"
#include "gameswf_movie.h"
#include "gameswf_timers.h"
#include "gameswf_textformat.h"
#include "gameswf_sound.h"

#ifdef HAVE_LIBXML
#include "gameswf_xml.h"
#include "gameswf_xmlsocket.h"
#endif


#ifdef _WIN32
#define snprintf _snprintf
#endif // _WIN32

// NOTES:
//
// Buttons
// on (press)                 onPress
// on (release)               onRelease
// on (releaseOutside)        onReleaseOutside
// on (rollOver)              onRollOver
// on (rollOut)               onRollOut
// on (dragOver)              onDragOver
// on (dragOut)               onDragOut
// on (keyPress"...")         onKeyDown, onKeyUp      <----- IMPORTANT
//
// Sprites
// onClipEvent (load)         onLoad
// onClipEvent (unload)       onUnload                Hm.
// onClipEvent (enterFrame)   onEnterFrame
// onClipEvent (mouseDown)    onMouseDown
// onClipEvent (mouseUp)      onMouseUp
// onClipEvent (mouseMove)    onMouseMove
// onClipEvent (keyDown)      onKeyDown
// onClipEvent (keyUp)        onKeyUp
// onClipEvent (data)         onData

// Text fields have event handlers too!

// Sprite built in methods:
// play()
// stop()
// gotoAndStop()
// gotoAndPlay()
// nextFrame()
// startDrag()
// getURL()
// getBytesLoaded()
// getBytesTotal()

// Built-in functions: (do these actually exist in the VM, or are they just opcodes?)
// Number()
// String()


// TODO builtins
//
// Number.toString() -- takes an optional arg that specifies the base
//
// parseInt(), parseFloat()
//
// Boolean() type cast
//
// typeof operator --> "number", "string", "boolean", "object" (also
// for arrays), "null", "movieclip", "function", "undefined"
//
// isNaN()
//
// Number.MAX_VALUE, Number.MIN_VALUE
//
// String.fromCharCode()



namespace gameswf
{
	
	//
	// action stuff
	//

	void	action_init();

	// Statics.
	bool	s_inited = false;
	smart_ptr<as_object>	s_global;
	fscommand_callback	s_fscommand_handler = NULL;


#define EXTERN_MOVIE
	
#ifdef EXTERN_MOVIE
	void attach_extern_movie(const char* url, const movie* target, const movie* root_movie)
	{
		tu_string infile = get_workdir();
		infile += url;

		movie_definition_sub*	md = create_library_movie_sub(infile.c_str());
		if (md == NULL)
		{
			log_error("can't create movie_definition_sub for %s\n", infile.c_str());
			return;
		}

		gameswf::movie_interface* extern_movie;

		if (target == root_movie)
		{
			extern_movie = create_library_movie_inst_sub(md);			
			if (extern_movie == NULL)
			{
				log_error("can't create extern root movie_interface for %s\n", infile.c_str());
				return;
			}
			set_current_root(extern_movie);
			movie* m = extern_movie->get_root_movie();

			m->on_event(event_id::LOAD);
		}
		else
		{
			extern_movie = md->create_instance();
			if (extern_movie == NULL)
			{
				log_error("can't create extern movie_interface for %s\n", infile.c_str());
				return;
			}
      
			save_extern_movie(extern_movie);
      
			character* tar = (character*)target;
			const char* name = tar->get_name();
			Uint16 depth = tar->get_depth();
			bool use_cxform = false;
			cxform color_transform =  tar->get_cxform();
			bool use_matrix = false;
			matrix mat = tar->get_matrix();
			float ratio = tar->get_ratio();
			Uint16 clip_depth = tar->get_clip_depth();

			movie* parent = tar->get_parent();
			movie* new_movie = extern_movie->get_root_movie();

			assert(parent != NULL);

			((character*)new_movie)->set_parent(parent);
       
			parent->replace_display_object(
				(character*) new_movie,
				name,
				depth,
				use_cxform,
				color_transform,
				use_matrix,
				mat,
				ratio,
				clip_depth);
		}
	}
#endif // EXTERN_MOVIE

	void	register_fscommand_callback(fscommand_callback handler)
	// External interface.
	{
		s_fscommand_handler = handler;
	}



	static bool string_to_number(double* result, const char* str)
	// Utility.  Try to convert str to a number.  If successful,
	// put the result in *result, and return true.  If not
	// successful, put 0 in *result, and return false.
	{
		char* tail = 0;
		*result = strtod(str, &tail);
		if (tail == str || *tail != 0)
		{
			// Failed conversion to Number.
			return false;
		}
		return true;
	}


	//
	// array object
	//


	struct as_array_object : public as_object
	{
// @@ TODO
//		as_array_object()
//		{
//			this->set_member("length", &array_not_impl);
//			this->set_member("join", &array_not_impl);
//			this->set_member("concat", &array_not_impl);
//			this->set_member("slice", &array_not_impl);
//			this->set_member("push", &array_not_impl);
//			this->set_member("unshift", &array_not_impl);
//			this->set_member("pop", &array_not_impl);
//			this->set_member("shift", &array_not_impl);
//			this->set_member("splice", &array_not_impl);
//			this->set_member("sort", &array_not_impl);
//			this->set_member("sortOn", &array_not_impl);
//			this->set_member("reverse", &array_not_impl);
//			this->set_member("toString", &array_not_impl);
//		}
	};

	void	array_not_impl(const fn_call& fn)
	{
		log_error("array methods not implemented yet\n");
	}


	//
	// as_as_function
	//

	void	as_as_function::operator()(const fn_call& fn)
	// Dispatch.
	{
		as_environment*	our_env = m_env;
		if (our_env == NULL)
		{
			our_env = fn.env;
		}
		assert(our_env);

		// Set up local stack frame, for parameters and locals.
		int	local_stack_top = our_env->get_local_frame_top();
		our_env->add_frame_barrier();

		if (m_is_function2 == false)
		{
			// Conventional function.

			// Push the arguments onto the local frame.
			int	args_to_pass = imin(fn.nargs, m_args.size());
			for (int i = 0; i < args_to_pass; i++)
			{
				assert(m_args[i].m_register == 0);
				our_env->add_local(m_args[i].m_name, fn.arg(i));
			}
		}
		else
		{
			// function2: most args go in registers; any others get pushed.
			
			// Create local registers.
			our_env->add_local_registers(m_local_register_count);

			// Handle the explicit args.
			int	args_to_pass = imin(fn.nargs, m_args.size());
			for (int i = 0; i < args_to_pass; i++)
			{
				if (m_args[i].m_register == 0)
				{
					// Conventional arg passing: create a local var.
					our_env->add_local(m_args[i].m_name, fn.arg(i));
				}
				else
				{
					// Pass argument into a register.
					int	reg = m_args[i].m_register;
					*(our_env->local_register_ptr(reg)) = fn.arg(i);
				}
			}

			// Handle the implicit args.
			int	current_reg = 1;
			if (m_function2_flags & 0x01)
			{
				// preload 'this' into a register.
				(*(our_env->local_register_ptr(current_reg))).set_as_object_interface(our_env->m_target);
				current_reg++;
			}

			if (m_function2_flags & 0x02)
			{
				// Don't put 'this' into a local var.
			}
			else
			{
				// Put 'this' in a local var.
				our_env->add_local("this", as_value(our_env->m_target));
			}

			// Init arguments array, if it's going to be needed.
			smart_ptr<as_array_object>	arg_array;
			if ((m_function2_flags & 0x04) || ! (m_function2_flags & 0x08))
			{
				arg_array = new as_array_object;

				as_value	index_number;
				for (int i = 0; i < fn.nargs; i++)
				{
					index_number.set_int(i);
					arg_array->set_member(index_number.to_string(), fn.arg(i));
				}
			}

			if (m_function2_flags & 0x04)
			{
				// preload 'arguments' into a register.
				(*(our_env->local_register_ptr(current_reg))).set_as_object_interface(arg_array.get_ptr());
				current_reg++;
			}

			if (m_function2_flags & 0x08)
			{
				// Don't put 'arguments' in a local var.
			}
			else
			{
				// Put 'arguments' in a local var.
 				our_env->add_local("arguments", as_value(arg_array.get_ptr()));
			}

			if (m_function2_flags & 0x10)
			{
				// Put 'super' in a register.
				log_error("TODO: implement 'super' in function2 dispatch (reg)\n");

				current_reg++;
			}

			if (m_function2_flags & 0x20)
			{
				// Don't put 'super' in a local var.
			}
			else
			{
				// Put 'super' in a local var.
				log_error("TODO: implement 'super' in function2 dispatch (var)\n");
			}

			if (m_function2_flags & 0x40)
			{
				// Put '_root' in a register.
				(*(our_env->local_register_ptr(current_reg))).set_as_object_interface(
					our_env->m_target->get_root_movie());
				current_reg++;
			}

			if (m_function2_flags & 0x80)
			{
				// Put '_parent' in a register.
				array<with_stack_entry>	dummy;
				as_value	parent = our_env->get_variable("_parent", dummy);
				(*(our_env->local_register_ptr(current_reg))) = parent;
				current_reg++;
			}

			if (m_function2_flags & 0x100)
			{
				// Put '_global' in a register.
				(*(our_env->local_register_ptr(current_reg))).set_as_object_interface(s_global.get_ptr());
				current_reg++;
			}
		}

		// Execute the actions.
		m_action_buffer->execute(our_env, m_start_pc, m_length, fn.result, m_with_stack, m_is_function2);

		// Clean up stack frame.
		our_env->set_local_frame_top(local_stack_top);

		if (m_is_function2)
		{
			// Clean up the local registers.
			our_env->drop_local_registers(m_local_register_count);
		}
	}


	//
	// Function/method dispatch.
	//


	as_value	call_method(
		const as_value& method,
		as_environment* env,
		as_object_interface* this_ptr,
		int nargs,
		int first_arg_bottom_index)
	// first_arg_bottom_index is the stack index, from the bottom, of the first argument.
	// Subsequent arguments are at *lower* indices.  E.g. if first_arg_bottom_index = 7,
	// then arg1 is at env->bottom(7), arg2 is at env->bottom(6), etc.
	{
		as_value	val;

		as_c_function_ptr	func = method.to_c_function();
		if (func)
		{
			// It's a C function.  Call it.
			(*func)(fn_call(&val, this_ptr, env, nargs, first_arg_bottom_index));
		}
		else if (as_as_function* as_func = method.to_as_function())
		{
			// It's an ActionScript function.  Call it.
			(*as_func)(fn_call(&val, this_ptr, env, nargs, first_arg_bottom_index));
		}
		else
		{
			log_error("error in call_method(): method is not a function\n");
		}

		return val;
	}


	as_value	call_method0(
		const as_value& method,
		as_environment* env,
		as_object_interface* this_ptr)
	{
		return call_method(method, env, this_ptr, 0, env->get_top_index() + 1);
	}
		
	const char*	call_method_parsed(
		as_environment* env,
		as_object_interface* this_ptr,
		const char* method_name,
		const char* method_arg_fmt,
		va_list args)
	// Printf-like vararg interface for calling ActionScript.
	// Handy for external binding.
	{
		log_msg("FIXME(%d): %s\n", __LINE__, __FUNCTION__);

#if 0
		static const int	BUFSIZE = 1000;
		char	buffer[BUFSIZE];
		array<const char*>	tokens;

		// Brutal crap parsing.  Basically null out any
		// delimiter characters, so that the method name and
		// args sit in the buffer as null-terminated C
		// strings.  Leave an intial ' character as the first
		// char in a string argument.
		// Don't verify parens or matching quotes or anything.
		{
			strncpy(buffer, method_call, BUFSIZE);
			buffer[BUFSIZE - 1] = 0;
			char*	p = buffer;

			char	in_quote = 0;
			bool	in_arg = false;
			for (;; p++)
			{
				char	c = *p;
				if (c == 0)
				{
					// End of string.
					break;
				}
				else if (c == in_quote)
				{
					// End of quotation.
					assert(in_arg);
					*p = 0;
					in_quote = 0;
					in_arg = false;
				}
				else if (in_arg)
				{
					if (in_quote == 0)
					{
						if (c == ')' || c == '(' || c == ',' || c == ' ')
						{
							// End of arg.
							*p = 0;
							in_arg = false;
						}
					}
				}
				else
				{
					// Not in arg.  Watch for start of arg.
					assert(in_quote == 0);
					if (c == '\'' || c == '\"')
					{
						// Start of quote.
						in_quote = c;
						in_arg = true;
						*p = '\'';	// ' at the start of the arg, so later we know this is a string.
						tokens.push_back(p);
					}
					else if (c == ' ' || c == ',')
					{
						// Non-arg junk, null it out.
						*p = 0;
					}
					else
					{
						// Must be the start of a numeric arg.
						in_arg = true;
						tokens.push_back(p);
					}
				}
			}
		}
#endif // 0


		// Parse va_list args
		int	starting_index = env->get_top_index();