faction.cpp

flash文件的解码程序

#include <stdarg.h>
#include "FAction.h"

void FlashActionRecord::WriteHeader(std::ostream &out, UWORD size)
{
	if(m_code > 0x80)
	{
		out.put( (char)m_code);
		WRITE_UWORD(size);
	}
	else
	{
		out.put( (char)m_code);			
	}

}

void FlashActionPush::Write(std::ostream &out)
{
	WriteHeader(out,len+1);
	out.put((char)type);
	out.write(data,len);
}
void FlashActionPush::Read(std::istream &in)
{
	ReadHeader(in);
	type = in.get();
	len = m_size-1;
	data = (char *)malloc(m_size);
	gcstrings.push_back(data);
	in.read(data,m_size-1);
}


FlashActionDefineFunction::FlashActionDefineFunction( char *function ...)
{
		
	m_functionName=function;

	va_list ap;
	va_start(ap, function);

	for(;;)
	{
		char *p=va_arg(ap,char*);
		if(p == 0) break;
		m_paramNames.push_back(p);
	}
	va_end(ap);

	m_numParams = m_paramNames.size();
	
}

FlashActionDefineFunction::~FlashActionDefineFunction()
{
}

void FlashActionDefineFunction::AddAction(FlashActionRecord *r)
{
	m_actions.push_back(r);
}

void FlashActionDefineFunction::Write(std::ostream &out)
{

	out.put((char)0x9B); // FActionDefineFunction tag
	
	int len=0;
	for(std::vector<char*>::iterator i=m_paramNames.begin(); i != m_paramNames.end(); i++)
	{
		len+=strlen(*i)+1;
	}

	WRITE_UWORD(strlen(m_functionName)+1+len+4);
	
	out << m_functionName;
	out.put((char)0);
	
	WRITE_UWORD(m_numParams);
	
	for(std::vector<char*>::iterator is=m_paramNames.begin(); is != m_paramNames.end(); is++)
	{
		out << (*is);
		out.put((char)0);
	}
	std::ostrstream tmp;
	for(std::vector<FlashActionRecord *>::iterator ir = m_actions.begin(); ir != m_actions.end(); ir++)
	{
		(*ir)->Write(tmp);
	}
	WRITE_UWORD(tmp.pcount());
	out.write(tmp.rdbuf()->str(),tmp.pcount());
}
void FlashActionDefineFunction::Read(std::istream &in)
{
	ReadHeader(in);
	
	{
		std::vector<char> str;
		unsigned int i;
		while((i = in.get()) != 0)
		{
			str.push_back((char)i);
		}
		m_functionName = (char*)malloc(str.size()+1);
		m_gcstrings.push_back(m_functionName);
		i=0;
	
		for(;i < str.size(); i++)
		{
			(m_functionName)[i]=str[i];
		}
		(m_functionName)[i]=0;
	}
	
	READ_UWORD(m_numParams);
	
	for(UDWORD it = 0; it < (UDWORD)m_numParams; it++)
	{
		std::vector<char> str;
		unsigned int i;
		while((i = in.get()) != 0)
		{
			str.push_back((char)i);
		}
		char *s = (char*)malloc(str.size()+1);
		m_paramNames.push_back(s);
		m_gcstrings.push_back(s);
		i=0;
	
		for(;i < str.size(); i++)
		{
			(m_paramNames[it])[i]=str[i];
		}
		(m_paramNames[it])[i]=0;
	}

	UWORD num_actions;
	READ_UWORD(num_actions);
	
	FlashActionVectorImporter i;
	i.Import(in,m_actions, records_delete, num_actions);
}

FlashActionConstantPool::FlashActionConstantPool(char *c ...)
{
	va_list ap;
	va_start(ap,c);

	m_length=0;

	char *p=c;
	m_strings.push_back(p);
	m_length+=strlen(p)+1;
	
	for(;;)
	{
		char *p=va_arg(ap,char*);
		if(p == 0) break;
		m_strings.push_back(p);
		m_length+=strlen(p)+1;
	}
	va_end(ap);
	
}
void FlashActionConstantPool::Write(std::ostream &out)
{
	out.put((char)0x88);
	WRITE_UWORD(m_length+2);
	WRITE_UWORD(m_strings.size());
	
	for(std::vector<char*>::iterator is=m_strings.begin(); is != m_strings.end(); is++)
	{
		out << (*is);
		out.put((char)0);
	}

}

void FlashActionConstantPool::Read(std::istream &in)
{
	ReadHeader(in);
	
	UWORD size;
	m_length = m_size - 2;
	READ_UWORD(size);
	
	for(UDWORD it = 0; it < (UDWORD)size; it++)
	{
		std::vector<char> str;
		unsigned int i;
		while((i = in.get()) != 0)
		{
			str.push_back((char)i);
		}
		char *s = (char*)malloc(str.size()+1);
		m_strings.push_back(s);
		m_gcstrings.push_back(s);
		
		i=0;
	
		for(;i < str.size(); i++)
		{
			(m_strings[it])[i]=str[i];
		}
		(m_strings[it])[i]=0;
	}
}

void FlashActionWith::AddAction(FlashActionRecord *r)
{
	m_actions.push_back(r);
}

void FlashActionWith::Write(std::ostream &out)
{
	out.put((char)0x94);		
	std::ostrstream tmp;
	for(std::vector<FlashActionRecord *>::iterator ir = m_actions.begin(); ir != m_actions.end(); ir++)
	{
		(*ir)->Write(tmp);
	}
	WRITE_UWORD(tmp.pcount());
	out.write(tmp.rdbuf()->str(),tmp.pcount());
}
void FlashActionWith::Read(std::istream &in)
{	
	ReadHeader(in);
	FlashActionVectorImporter i;
	i.Import(in,m_actions, records_delete);
}
void FlashTagDoAction::AddAction(FlashActionRecord *r)
{
	records.push_back(r);
}
FlashTagDoAction::~FlashTagDoAction() 
{
}
std::ostream &operator<< (std::ostream &out, FlashTagDoAction &data)
{
	std::ostrstream tmp;
	for(std::vector<FlashActionRecord*>::iterator i=data.records.begin(); i < data.records.end(); i++)
	{
		(*i)->Write(tmp);
	}
	
	out << FlashTagHeader(12, tmp.pcount()+1);
	char *outputBuffer = tmp.rdbuf()->str();