/**
* @function ferite_init_error_system
* @declaration void ferite_init_error_system( FeriteScript *script, FeriteNamespace *ns )
* @brief Setup the special error handling class on a script
* @param FeriteScript *script The current script
* @param FeriteNamespace *ns The namespace in which the class should be registered
*/
void ferite_init_error_system( FeriteScript *script, FeriteNamespace *ns )
{
FeriteClass *ferite_error_class = NULL;
FeriteVariable *var, *errobj = NULL;
FeriteNamespaceBucket *nsb = NULL;
FE_ENTER_FUNCTION;
ferite_error_class = ferite_register_class( script, ns, "Error" );
ferite_register_class_variable( script, ferite_error_class, "num", ferite_create_number_long_variable( script, "num", 0, FE_STATIC ), 0 );
ferite_register_class_variable( script, ferite_error_class, "str", ferite_create_string_variable( script, "str", NULL, FE_STATIC ), 0 );
ferite_register_class_variable( script, ferite_error_class, "backtrace", ferite_create_uarray_variable( script, "backtrace", 32, FE_STATIC ), 0 );
fe_create_cls_fnc( script, ferite_error_class, "constructor", ferite_error_constructor_sn, "sn", FE_FALSE );
fe_create_cls_fnc( script, ferite_error_class, "constructor", ferite_error_constructor_s, "s", FE_FALSE );
fe_create_cls_fnc( script, ferite_error_class, "backtrace", ferite_error_backtrace, "", FE_FALSE );
nsb = ferite_find_namespace( script, script->mainns, "err", FENS_VAR );
if( nsb != NULL ) {
errobj = ferite_build_object( script, ferite_error_class );
var = nsb->data;
VAO(var) = VAO(errobj);
VAO(errobj) = NULL;
ferite_variable_destroy( script, errobj );
}
FE_LEAVE_FUNCTION(NOWT);
}
int create_address(FeriteScript *script, FeriteVariable *object, ADDRESS *addr) {
FeriteVariable *v;
if( addr->mailbox ) {
v = fe_new_str( "mailbox", addr->mailbox, 0, FE_CHARSET_DEFAULT );
if( v == NULL ) {
//set_error_string( script, self,"Internal ferite error" );
return -1;
}
ferite_object_set_var(script, VAO(object), "mailbox", v );
}
if( addr->host ) {
v = fe_new_str("host", addr->host, 0, FE_CHARSET_DEFAULT );
if( v == NULL ) {
//set_error_string( script, self, "Internal error" );
return -1;
}
ferite_object_set_var(script, VAO(object), "host", v );
}
if( addr->personal ) {
v = fe_new_str("name", addr->personal, 0, FE_CHARSET_DEFAULT );
if( v == NULL ) {
//set_error_string( script, self, "Internal error" );
return -1;
}
ferite_object_set_var(script, VAO(object), "name", v );
}
return 0;
}
FeriteVariable *create_ferite_header_object( FeriteScript *script, ENVELOPE *env )
{
FeriteVariable *header = NULL, *v = NULL;
FeriteNamespaceBucket *nsb = NULL;
#define BUFSIZE 1025
char buf[BUFSIZE];
int i = 0;
if( env == NULL)
return NULL;
ADDRESS *address_source[6] = { env->from, env->reply_to, env->cc, env->bcc, env->sender, env->to };
char *address_target[6] = { "from", "reply_to" , "cc", "bcc", "sender" , "to" };
int n_address_source = 6;
char *source[5] = { env->subject, env->date, env->message_id, env->in_reply_to, env->references };
char *target[5] = { "subject", "date", "ID", "in_reply_to", "references" };
int n_source = 5;
nsb = ferite_find_namespace( script, script->mainns, "Mail.MessageHeader", FENS_CLS );
if( nsb == NULL)
return NULL;
header = ferite_build_object( script, (FeriteClass *)nsb->data );
if( header == NULL )
return NULL;
//Parse each address structure in address_source[] and write the result to the
//corresonding object member in address_target[]
for(i=0; i < n_address_source; i++) {
v = create_address_list( script, address_source[i] );
if( v == NULL ) {
//set_error_string( script, self, "Couldn't create address list" );
return NULL;
}
ferite_object_set_var(script, VAO(header), address_target[i], v );
}
//Copy each header-field in source[] to the
//corresonding object member in address_target[]
for(i=0; i< n_source; i++) {
if( source[i] ) {
v = fe_new_str(target[i], source[i] , 0, FE_CHARSET_DEFAULT );
if( v == NULL ) {
//set_error_string( script, self, "Couldn't create mail header" );
return NULL;
}
ferite_object_set_var(script, VAO(header), target[i], v );
if( debug_cmail_module && strcmp( target[i], "subject" ) == 0 ) {
output_printf(OUTPUT_DEBUG,"module.mail: Processing email with subject: '%s'", source[i] );
}
}
}
return header;
}
FeriteVariable *create_element_node( FeriteScript *script, xmlDocPtr doc, xmlNodePtr node )
{
FeriteVariable *obj = NULL;
FeriteClass *cls = NULL;
if(( cls = ferite_find_class( script, script->mainns, "XML.Element" ) ) == NULL) {
ferite_error( script , 0, "Can't locate class XML.Element" );
}
obj = ferite_new_object( script, cls, NULL );
((XMLDoc *)VAO(obj)->odata)->doc = doc;
((XMLDoc *)VAO(obj)->odata)->node = node;
return obj;
}
FeriteVariable *ferite_amtarray_get_exceptions( FeriteScript *script, FeriteAMTArray *array, FeriteVariable *index, int want_exceptions )
{
FeriteVariable *rval = NULL;
FE_ENTER_FUNCTION;
switch(F_VAR_TYPE(index)) {
case F_VAR_LONG:
rval = ferite_amtarray_get_index( script, array, VAI(index) );
if( want_exceptions && rval == NULL ) {
ferite_error( script, 0, "Index does not exist '%d' in array.\n", VAI(index) );
FE_LEAVE_FUNCTION( NULL );
}
break;
case F_VAR_DOUBLE:
rval = ferite_amtarray_get_index( script, array, (int)floor(VAF(index)) );
if( want_exceptions && rval == NULL ) {
ferite_error( script, 0, "Index does not exist '%d' in array.\n", (int)floor(VAF(index)) );
FE_LEAVE_FUNCTION( NULL );
}
break;
case F_VAR_STR:
rval = ferite_amtarray_get_hash( script, array, FE_STR2PTR(index));
if( want_exceptions && rval == NULL ) {
ferite_error( script, 0, "Invalid index: no such key '%s' in array.\n", FE_STR2PTR(index) );
FE_LEAVE_FUNCTION( NULL );
}
break;
case F_VAR_OBJ: {
FeriteVariable *hash_value = NULL, *return_value = NULL;
FeriteFunction *hash = ferite_object_get_function_for_params( script, VAO(index), "hash", NULL );
hash_value = ferite_call_function( script, VAO(index), NULL, hash, NULL );
if( F_VAR_TYPE(hash_value) != F_VAR_STR ) {
if( want_exceptions )
ferite_error( script, 0, "Invalid index: unable to get string key from object to access array.\n" );
FE_LEAVE_FUNCTION(NULL);
}
return_value = ferite_amtarray_get_hash( script, array, FE_STR2PTR(hash_value) );
if( want_exceptions && return_value == NULL ) {
ferite_error( script, 0, "Invalid index: no such key '%s' (otained from object hash) in array.\n", FE_STR2PTR(hash_value) );
}
ferite_variable_destroy( script, hash_value );
FE_LEAVE_FUNCTION( return_value );
}
}
FE_LEAVE_FUNCTION( rval );
}
FeriteVariable *create_ferite_mail_object( FeriteScript *script, FeriteVariable *header, FeriteVariable *content )
{
FeriteVariable *mailobject;
FeriteNamespaceBucket *nsb;
nsb = ferite_find_namespace( script, script->mainns, "Mail.Message", FENS_CLS );
if( nsb == NULL )
return NULL;
mailobject = ferite_build_object( script, (FeriteClass *)nsb->data );
if( mailobject == NULL )
return NULL;
if( header )
ferite_object_set_var(script, VAO(mailobject), "header", header );
if( content )
ferite_object_set_var(script, VAO(mailobject), "content", content );
return mailobject;
}
BODY *create_imap_content_object(FeriteScript* script, FeriteVariable* fe_parent)
{
FeriteVariable *parts_list,*fe_child,*v;
BODY *root,*new_body;
PART *new_part,*last_part = NULL;
int i=0;
//Get array of child objects
parts_list = ferite_hash_get( script, VAO(fe_parent)->variables->variables, "parts");
//This is true if the top level is not a multipart
if( parts_list == NULL )
return( create_imap_content_leaf( script, fe_parent ));
root = mail_newbody();
root->type=TYPEMULTIPART;
v = ferite_hash_get( script, VAO(fe_parent)->variables->variables, "subtype");
RETURN_IF_NULL(v);
if( VAS(v)->data )
root->subtype = cpystr( VAS(v)->data );
//Loop trough child array
i=0;
while( i < VAUA(parts_list)->size) {
new_part = mail_newbody_part();
fe_child = ferite_uarray_get_index( script, VAUA(parts_list) , i );
RETURN_IF_NULL(fe_child);
// Is it a multipart or a leaf?
if( ferite_hash_get( script, VAO(fe_child)->variables->variables, "parts"))
new_body = create_imap_content_object( script , fe_child );
else
new_body = create_imap_content_leaf( script, fe_child );
RETURN_IF_NULL(new_body);
new_part->body = *new_body; //Fixme, this sucks
if( last_part == NULL )
root->nested.part = last_part = new_part;
else
last_part = last_part->next = new_part;
i++;
}
return root;
}
FeriteVariable *system_call_tm( FeriteScript *script, struct tm *tm )
{
FeriteVariable *object = NULL, *pointer = NULL, **args = NULL;
FeriteClass *cls = NULL;
FeriteFunction *function = NULL;
if((cls = ferite_find_class( script, script->mainns, "Date" )) != NULL)
{
pointer = system_create_pointer_var( script, "struct::tm", tm );
object = ferite_new_object( script, cls, NULL );
function = ferite_object_get_function( script, VAO(object), "__RegisterFromPointer__" );
args = ferite_create_parameter_list_from_data( script, "o", VAO(pointer) );
ferite_variable_destroy( script, ferite_call_function( script, VAO(object), NULL, function, args ) );
ferite_variable_destroy( script, pointer );
ferite_delete_parameter_list( script, args );
FE_RETURN_VAR( object );
}
FE_RETURN_NULL_OBJECT;
}
/**
* @function ferite_raise_script_error
* @declaration void ferite_raise_script_error( FeriteScript *script, int err, char *fmt, ... )
* @brief Raise an exception within the ferite engine.
* @param FeriteScript *script The running script
* @param int err The error code
* @param char *fmt The format of the error string
* @description Use the same formating codes as printf with this function
*/
void ferite_raise_script_error( FeriteScript *script, int err, char *fmt, ... )
{
FeriteNamespaceBucket *nsb = NULL;
FeriteVariable *global_error_object = NULL, *new_error_object = NULL, *backtrace = NULL;
FeriteVariable *error_object_str = NULL, *error_object_num = NULL, *error_object_backtrace = NULL;
FeriteBuffer *error_buffer = NULL;
char *msg;
va_list ap;
FE_ENTER_FUNCTION;
va_start( ap, fmt );
error_buffer = ferite_buffer_new(script, 0);
ferite_buffer_vprintf( script, error_buffer, fmt, &ap );
msg = ferite_buffer_get( script, script->error, NULL );
FUD(("ERROR RAISED: %s %d\n", msg, err ));
nsb = ferite_namespace_element_exists( script, script->mainns, "err" );
FE_ASSERT( nsb && nsb->type == FENS_VAR );
global_error_object = nsb->data;
script->error_state = FE_ERROR_THROWN;
if( VAO(global_error_object) == NULL )
{
nsb = ferite_namespace_element_exists( script, script->mainns, "Error" );
if( nsb == NULL )
{
FE_LEAVE_FUNCTION( NOWT );
exit(1);
}
new_error_object = ferite_new_object( script, nsb->data, NULL );
VAO(global_error_object) = VAO(new_error_object);
FINCREF(VAO(global_error_object));
ferite_variable_destroy( script, new_error_object );
}
error_object_str = ferite_object_get_var( script, VAO(global_error_object), "str" );
ferite_str_set( script, VAS(error_object_str), msg, strlen(msg), FE_CHARSET_DEFAULT );
ffree( msg );
error_object_num = ferite_object_get_var( script, VAO(global_error_object), "num" );
VAI(error_object_num) = err;
backtrace = ferite_generate_backtrace( script, FE_FALSE );
error_object_backtrace = ferite_object_get_var( script, VAO(global_error_object), "backtrace");
ferite_variable_fast_assign( script, error_object_backtrace, backtrace );
ferite_buffer_delete( script, error_buffer );
FE_LEAVE_FUNCTION( NOWT );
}
ADDRESS *create_imap_address( FeriteScript* script, FeriteVariable* fe_object){
ADDRESS *root=NULL, *newaddr;
FeriteVariable *fe_list,*v,*fe_addr;
int i;
RETURN_IF_NULL(fe_object && VAO(fe_object));
fe_list = ferite_hash_get( script, VAO(fe_object)->variables->variables, "list" );
RETURN_IF_NULL(fe_list);
for( i=0; i< VAUA(fe_list)->size; i++ ){
fe_addr = ferite_uarray_get_index( script, VAUA(fe_list) , i );
RETURN_IF_NULL(fe_addr);
if(root == NULL)
root = newaddr = mail_newaddr();
else
newaddr = newaddr->next = mail_newaddr();
v = ferite_hash_get( script, VAO(fe_addr)->variables->variables , "mailbox");
RETURN_IF_NULL(v);
if(VAS(v)->data)
newaddr->mailbox = cpystr(VAS(v)->data);
v = ferite_hash_get( script, VAO(fe_addr)->variables->variables , "host");
RETURN_IF_NULL(v);
if(VAS(v)->data)
newaddr->host = cpystr(VAS(v)->data);
v = ferite_hash_get( script, VAO(fe_addr)->variables->variables , "name");
RETURN_IF_NULL(v);
if(VAS(v)->data)
newaddr->personal = cpystr(VAS(v)->data);
}
return root;
}
G_Data QuadFactory::GetData() {
const std::array<vec3, 4> vertices = {
vec3(-1,-1,0),
vec3(1,-1,0),
vec3(1,1,0),
vec3(-1,1,0)
};
// Indices
// right now these only work for triangle fan
const std::array<uint32_t, 4> indices = {
0,1,2,3
};
// For quads just make the VAO once
GLuint VAO(0);
if (m_CachedVAOs.size())
VAO = m_CachedVAOs.begin()->second;
// If the VAO doesn't exist, create it
else {
// Generate bufferse for vertices and indices
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
std::array<GLuint, 2> buffers;
glGenBuffers(buffers.size(), buffers.data());
//vertices
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vec3)*vertices.size(), vertices.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(G_Data::GetPosHandle());
glVertexAttribPointer(G_Data::GetPosHandle(), 3, GL_FLOAT, 0, 0, 0);
//indices
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t)*indices.size(), indices.data(), GL_STATIC_DRAW);
glBindVertexArray(0);
m_CachedVAOs["quad"] = VAO;
}
// Create MV given current state
mat4 MV = glm::translate(m_Trans)*glm::mat4_cast(m_Rot)*glm::scale(m_Scale);
// return info given current state
return{ VAO, GLuint(indices.size()), m_Color, MV };
}
FeriteVariable *create_address_list(FeriteScript *script, ADDRESS *root) {
FeriteNamespaceBucket *nsb;
FeriteVariable *address_list, *item_list, *item;
ADDRESS *curr;
int error;
nsb = ferite_find_namespace( script, script->mainns, "Mail.AddressList", FENS_CLS );
if( nsb == NULL )
return NULL;
address_list = ferite_build_object( script, (FeriteClass *)nsb->data );
if( address_list == NULL )
return NULL;
//Get the array (member of address_list) and populate it with
//the entries in the linked list current
item_list = ferite_hash_get( script, VAO(address_list)->variables->variables, "list" );
nsb = ferite_find_namespace( script, script->mainns, "Mail.Address", FENS_CLS );
if( nsb == NULL ) {
return NULL;
}
curr=root;
while( curr ) {
item = ferite_build_object( script, (FeriteClass *)nsb->data );
if( item == NULL )
return NULL;
error = create_address( script, item, curr);
if(error) {
return NULL;
}
ferite_uarray_add( script, VAUA(item_list), item, NULL , FE_ARRAY_ADD_AT_END);
curr = curr->next;
}
return address_list;
}
/**
* @function ferite_set_error
* @declaration void ferite_set_error( FeriteScript *script, int num, char *fmt, ... )
* @brief Same as ferite_error except this wont raise an exception at runtime
*/
void ferite_set_error( FeriteScript *script, int num, char *fmt, ... )
{
FeriteNamespaceBucket *nsb = NULL;
FeriteVariable *global_error_object = NULL, *new_error_object = NULL;
FeriteVariable *errstr = NULL, *erno = NULL;
va_list ap;
char *buf = NULL;
FE_ENTER_FUNCTION;
if( !script->is_being_deleted && (script->parent == NULL || !script->parent->is_being_deleted) )
{
buf = fmalloc( 4096 );
va_start( ap, fmt );
vsprintf( buf, fmt, ap );
nsb = ferite_namespace_element_exists( script, script->mainns, "err" );
FE_ASSERT( nsb && nsb->type == FENS_VAR );
global_error_object = nsb->data;
if( VAO(global_error_object) == NULL )
{
nsb = ferite_namespace_element_exists( script, script->mainns, "Error" );
new_error_object = ferite_new_object( script, nsb->data, NULL );
VAO(global_error_object) = VAO(new_error_object);
FINCREF(VAO(global_error_object));
ferite_variable_destroy( script, new_error_object );
}
errstr = ferite_object_get_var( script, VAO(global_error_object), "str" );
ferite_str_set( script, VAS(errstr), buf, strlen(buf), FE_CHARSET_DEFAULT );
erno = ferite_object_get_var( script, VAO(global_error_object), "num" );
VAI(erno) = num;
ffree( buf );
va_end( ap );
}
FE_LEAVE_FUNCTION( NOWT );
}
/**
* @function ferite_new_object
* @declaration FeriteVariable *ferite_new_object( FeriteScript *script, FeriteClass *nclass, FeriteVariable **plist)
* @brief Create a new object - the C equivalent to the ferite 'new' keyword.
* @param FeriteScript *script The script to create the object within.
* @param FeriteClass *nclass The class to instantiate an object from
* @param FeriteVariable **plist The parameters to be passed to the objects constructor. This can be NULL for an empty
list.
* @return A variable that references the newly created object.
* @warning The return variable is marked as disposable. If you wish to retain a reference and return the object from a
native function you must 'UNMARK_VARIABLE_AS_DISPOSABLE'
*/
FeriteVariable *ferite_new_object( FeriteScript *script, FeriteClass *nclass, FeriteVariable **plist)
{
FeriteVariable *ptr = NULL, *rval = NULL;
FeriteFunction *func = NULL;
FeriteVariable **params = NULL;
FE_ENTER_FUNCTION;
if(nclass != NULL)
{
if( nclass->state == FE_ITEM_IS_ABSTRACT )
{
ferite_error( script, 0, "You can't create instances of the abstract class %s\n", nclass->name );
FE_LEAVE_FUNCTION( NULL );
}
else if( nclass->state == FE_ITEM_IS_PROTOCOL )
{
ferite_error( script, 0, "You can't create instances of the protocol %s\n", nclass->name );
FE_LEAVE_FUNCTION( NULL );
}
if( plist != NULL )
params = plist;
else
params = ferite_create_parameter_list( script,3 );
ptr = ferite_build_object(script,nclass);
FUD(("NEWOBJECT: Marking as disposable\n" ));
MARK_VARIABLE_AS_DISPOSABLE( ptr );
FUD(("NEWOBJECT: Searching for constructor\n" ));
func = ferite_find_constructor( script, VAO(ptr), params );
if( func != NULL ) {
FUD(("OPS: Calling constructor in class %s\n", nclass->name ));
if( func->type == FNC_IS_EXTRL ) {
EXTERNAL_ENTER(func);
rval = (func->fncPtr)( script, VAO(ptr), NULL, func, params );
EXTERNAL_EXIT();
}
else
rval = ferite_script_function_execute( script, VAO(ptr), NULL, func, params );
if( rval == NULL || (rval != NULL && F_VAR_TYPE(rval) == F_VAR_OBJ && VAO(rval) == NULL) )
{
if( rval == NULL ) {
/* So that I don't forget again, this is if the function returns NULL, not if the
* ferite function called returns null */
ferite_error( script, 0, "Unable to instantiate object from class '%s'\n", nclass->name );
}
/* clean up the class */
ferite_delete_object_variable_list( script, VAO(ptr)->variables );
VAO(ptr)->variables = NULL;
VAO(ptr)->functions = NULL;
VAO(ptr)->klass = NULL;
FDECREF(VAO(ptr));
/* set our return val to NULL */
VAO(ptr) = NULL;
}
if( rval != NULL )
ferite_variable_destroy( script, rval );
}
else
ferite_error( script, 0, "Unable to find constructor of the class '%s' for the given parameters\n", nclass->name );
if( plist == NULL )
ferite_delete_parameter_list( script, params );
}
FE_LEAVE_FUNCTION( ptr );
}
ENVELOPE *create_imap_envelope( FeriteScript *script, FeriteVariable *header ){
ENVELOPE *env = mail_newenvelope();
FeriteVariable *v;
ADDRESS *a;
int i;
v = ferite_hash_get( script, VAO(header)->variables->variables, "to" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find to address");
a = create_imap_address( script, v );
if(a)
env->to = a;
v = ferite_hash_get( script, VAO(header)->variables->variables, "from" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find from address");
a = create_imap_address( script, v );
if(a)
env->from = a;
v = ferite_hash_get( script, VAO(header)->variables->variables, "cc" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find cc address");
a = create_imap_address( script, v );
if(a)
env->cc = a;
v = ferite_hash_get( script, VAO(header)->variables->variables, "bcc" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find bcc address");
a = create_imap_address( script, v );
if(a)
env->bcc = a;
v = ferite_hash_get( script, VAO(header)->variables->variables, "return_path" );
if(v) {
a = create_imap_address( script, v );
if(a)
env->return_path = a;
}
if(env->return_path == NULL) {
v = ferite_hash_get( script, VAO(header)->variables->variables, "from" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find create return path");
a = create_imap_address( script, v );
if(a)
env->return_path = a;
}
v = ferite_hash_get( script, VAO(header)->variables->variables, "sender" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find sender");
a = create_imap_address( script, v );
if(a)
env->sender = a;
v = ferite_hash_get( script, VAO(header)->variables->variables, "subject" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find subject");
env->subject = cpystr( VAS(v)->data );
RETURN_IF_NULL( env->subject );
v = ferite_hash_get( script, VAO(header)->variables->variables, "in_reply_to" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find in reply to header");
env->in_reply_to = cpystr( VAS(v)->data );
RETURN_IF_NULL( env->in_reply_to );
v = ferite_hash_get( script, VAO(header)->variables->variables, "ID" );
ERROR_IF_NULL(v, script, "Unable to create imap envelope - unable to find proposed message id");
env->message_id = cpystr( VAS(v)->data );
return env;
}
BODY* create_imap_content_leaf( FeriteScript *script, FeriteVariable *leaf ){
BODY *body = NULL;
FeriteVariable *v = NULL;
body = mail_newbody();
// fixme NULL/0 ?
v = ferite_hash_get(script,VAO(leaf)->variables->variables,"encoding");
RETURN_IF_NULL(v);
body->encoding=VAI(v);
v = ferite_hash_get( script, VAO(leaf)->variables->variables, "content");
RETURN_IF_NULL(v);
//fixme memcopy? Encode?
body->contents.text.data =strdup(VAS(v)->data);
body->contents.text.size =strlen(VAS(v)->data); //fixme
v = ferite_hash_get( script, VAO(leaf)->variables->variables, "type" );
RETURN_IF_NULL(v);
body->type=VAI(v);
v = ferite_hash_get(script,VAO(leaf)->variables->variables,"subtype");
RETURN_IF_NULL(v);
body->subtype=cpystr( VAS(v)->data );
v = ferite_hash_get(script,VAO(leaf)->variables->variables,"ID");
RETURN_IF_NULL(v);
if( VAS(v)->length > 0 ) {
body->id = cpystr( VAS(v)->data );
}
v = ferite_hash_get(script,VAO(leaf)->variables->variables,"filename");
RETURN_IF_NULL(v);
if( strlen(VAS(v)->data)) {
PARAMETER *param = mail_newbody_parameter();
param->attribute = cpystr("filename");
param->value=cpystr( VAS(v)->data );
body->disposition.parameter = param;
body->disposition.type = cpystr("attachment");
}
v = ferite_hash_get( script, VAO(leaf)->variables->variables, "filepath" );
RETURN_IF_NULL(v);
if( strlen(VAS(v)->data) ) {
off_t size;
int fd;
char *buf;
struct stat statinfo;
fd = open(VAS(v)->data,O_RDONLY);
if( fd == -1 ) {
char buffer[2048];
sprintf(buffer, "Unable to create email content leaf, unable to open file: %s", VAS(v)->data);
ERROR_IF_NULL(NULL, script, buffer);
}
size=lseek(fd,0,SEEK_END);
lseek(fd,0,SEEK_SET);
buf=malloc(size*sizeof(char)+1);
if(buf){
read(fd,buf,size);
body->contents.text.data=buf;
body->contents.text.size=size;
close(fd);
}
else{
ferite_error(script, 0, "Out of memory\n");
close(fd);
return NULL;
}
}
v = ferite_hash_get(script,VAO(leaf)->variables->variables, "charset");
RETURN_IF_NULL(v);
if( strlen(VAS(v)->data) ) {
PARAMETER *param = mail_newbody_parameter();
if( body->parameter )
param->next = body->parameter;
body->parameter=param;
body->parameter->attribute=cpystr("CHARSET");
body->parameter->value=cpystr(VAS(v)->data);
}
return body;
}
FeriteVariable *create_ferite_content_object( FeriteScript *script, MAILSTREAM *stream, BODY *body, int msgno, char *sec )
{
if( body != NULL ) {
FeriteVariable *object = NULL,*v = NULL;
FeriteNamespaceBucket *nsb = NULL;
char *object_name = NULL;
object_name = ( body->type == TYPEMULTIPART ) ? "Mail.MessageMultiPart" : "Mail.MessagePart" ;
nsb = ferite_find_namespace( script, script->mainns, object_name , FENS_CLS );
if( nsb == NULL )
return NULL;
object = ferite_build_object( script, (FeriteClass *)nsb->data );
if( object == NULL )
return NULL;
v = fe_new_lng("type",body->type);
ferite_object_set_var(script, VAO(object), "type", v);
output_printf(OUTPUT_DEBUG,"module.mail: setting type %d", body->type);
if( body->subtype ) {
v = fe_new_str( "subtype", body->subtype, 0, FE_CHARSET_DEFAULT );
ferite_object_set_var( script, VAO(object), "subtype", v );
}
if( body->type == TYPEMULTIPART ) {
PART *part = NULL;
int i = 0;
char sec2[200];
FeriteVariable *ret = NULL, *parts = NULL;
parts = ferite_hash_get(script,VAO(object)->variables->variables,"parts");
part = body->nested.part;
while( part ) {
i++;
if( sec ) {
snprintf(sec2,200,"%s.%d",sec,i);
} else {
snprintf(sec2,200,"%d",i);
}
ret = create_ferite_content_object( script, stream, &part->body, msgno, sec2 );
ferite_uarray_add( script, VAUA(parts), ret , NULL, FE_ARRAY_ADD_AT_END );
part = part->next;
}
v = fe_new_lng("nparts", i);
ferite_object_set_var(script, VAO(object), "nparts", v );
}
else
{
long len = 0,len2 = 0;
unsigned char *buf = NULL, *buf2 = NULL;
SIZEDTEXT src, dest;
FeriteVariable *v = NULL;
PARAMETER *param = NULL;
int i = 0;
if( sec == NULL )
sec = "1";
buf = mail_fetchbody( stream, msgno, sec, &len );
switch(body->encoding){
case ENCQUOTEDPRINTABLE:
if( debug_cmail_module )
output_printf(OUTPUT_DEBUG,"module.mail: Decoding from encoded quotable");
buf2 = rfc822_qprint(buf,len,&len2);
break;
case ENCBASE64:
if( debug_cmail_module )
output_printf(OUTPUT_DEBUG,"module.mail: Decoding from base64");
buf2=rfc822_base64(buf,len,&len2);
break;
default:
buf2=buf;
len2=len;
}
if( debug_cmail_module ) {
output_printf(OUTPUT_DEBUG,"module.mail: id: %s, description: %s", body->id, body->description);
output_printf(OUTPUT_DEBUG,"module.mail: block type: %d.%s", body->type, body->subtype);
}
if( body->parameter ) /* Try and get the content type correctly */ {
PARAMETER *ptr = body->parameter;
while( ptr != NULL ) {
if( caseless_compare( ptr->attribute, "charset" ) ) {
if( debug_cmail_module )
output_printf(OUTPUT_DEBUG,"module.mail: Found content type for block: %s", ptr->value);
v = fe_new_str("charset", ptr->value, 0, FE_CHARSET_DEFAULT);
ferite_object_set_var(script, VAO(object), "charset", v);
}
ptr = ptr->next;
}
}
v = fe_new_bin_str("content", buf2, len2, FE_CHARSET_DEFAULT );
ferite_object_set_var(script, VAO(object), "content", v );
v = fe_new_lng("encoding", body->encoding );
ferite_object_set_var(script, VAO(object), "encoding", v );
if( body->id ) {
v = fe_new_str("ID", body->id, strlen(body->id), FE_CHARSET_DEFAULT);
ferite_object_set_var(script, VAO(object), "ID", v);
}
if( body->disposition.type && strcasecmp(body->disposition.type, "attachment") == 0) {
param = body->disposition.parameter;
while(param){
if( param->attribute && ((strcasecmp(param->attribute,"filename") == 0) ||
(strcasecmp(param->attribute,"name") == 0) ||
(strcasecmp(param->attribute,"name*") == 0) ||
(strcasecmp(param->attribute,"filename*") == 0) )) {
v = fe_new_str("filename", param->value, 0, FE_CHARSET_DEFAULT );
ferite_object_set_var(script, VAO(object), "filename", v );
break;
}
param=param->next;
}
}
/* If filename was not found in Content-Disposition header search for it among the parameters */
if( strcmp(VAS(ferite_object_get_var(script, VAO(object), "filename"))->data, "") == 0 ) {
param = body->parameter;
while(param){
if( param->attribute && ((strcasecmp(param->attribute,"filename") == 0) ||
(strcasecmp(param->attribute,"name") == 0))) {
v = fe_new_str("filename", param->value, 0, FE_CHARSET_DEFAULT );
ferite_object_set_var(script, VAO(object), "filename", v );
break;
}
param = param->next;
}
}
}
return object;
}
return NULL;
}
/*{{{ FeriteVariable *ferite_build_object( FeriteScript *script, FeriteClass *nclass) */
FeriteVariable *ferite_build_object( FeriteScript *script, FeriteClass *nclass)
{
FeriteVariable *ptr = NULL;
FE_ENTER_FUNCTION;
if( nclass != NULL )
{
FUD(("BUILDOBJECT: Creating an instance of %s\n", nclass->name ));
ptr = ferite_create_object_variable( script, nclass->name, FE_ALLOC );
if( script )
VAO(ptr) = ferite_stack_pop( script, script->objects );
if( VAO(ptr) == NULL ) {
VAO(ptr) = fmalloc( sizeof( FeriteObject ) );
FUD(( "Allocating object %p\n", VAO(ptr) ));
}
VAO(ptr)->name = fstrdup( nclass->name );
VAO(ptr)->klass = nclass;
FUD(("BUILDOBJECT: Creating a duplicate varaible hash\n"));
VAO(ptr)->variables = ferite_duplicate_object_variable_list( script, nclass );
FUD(("BUILDOBJECT: Linking function list up\n"));
VAO(ptr)->functions = nclass->object_methods;
VAO(ptr)->oid = nclass->id;
VAO(ptr)->odata = NULL;
VAO(ptr)->refcount = 1;
ferite_add_to_gc( script, VAO(ptr) );
}
FE_LEAVE_FUNCTION( ptr );
}
