jk_env.c

Tomcat 4.1与WebServer集成组件的源代码包.

            fprintf( stderr, "Error getting factory for %s \n",  type );
        }
        return NULL;
    }

    workerPool=pool->create(env, pool, HUGE_POOL_SIZE);
    

    /** Generate a unique name if none is specified
     */
    if( localName==NULL ) {
        localName=workerPool->calloc( env, workerPool,  10 );
        sprintf( (char *)localName, "%d", jk_env_globalEnv->id++ );
    }

    name=workerPool->calloc( env, workerPool,  strlen( type ) + strlen( localName ) + 2 );
    strcpy( name, type );
    strcat( name, ":");
    strcat( name, localName );
    
    result=(jk_bean_t *)workerPool->calloc( env, workerPool, sizeof( jk_bean_t ));
    result->pool=workerPool;
    result->type= workerPool->pstrdup( env, workerPool, type);
    result->name= workerPool->pstrdup( env, workerPool, name);
    result->localName=workerPool->pstrdup( env, workerPool, localName);
    result->debug=0;
    result->state=JK_STATE_NEW;
    result->disabled=JK_FALSE;
    result->settings=NULL;
    result->getAttributeInfo=NULL;
    result->setAttributeInfo=NULL;
    
    fac( env, workerPool, result, result->type, result->name );

    if( result->object==NULL ) {
        if( env->l ) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "env.createBean2(): Factory error creating %s ( %s, %s)\n", name,
                          type, localName);
        } else {
            fprintf(stderr, "env.createBean2(): Factory error creating %s ( %s, %s)\n", name,
                    type, localName);
        }
        return NULL;
    }

    if( env->debug > 0 ) {
        if( env->l == NULL ) 
            fprintf(stderr,"env.createBean2(): register %s %#lx\n", result->name, result->object);
        else 
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "env.createBean2(): register %s %#lx\n", result->name, result->object);
    }

    jk_env_globalEnv->_objects->put( env, jk_env_globalEnv->_objects, result->name, result, NULL );
    
    for( i=jk_env_globalEnv->_objects->size( env, jk_env_globalEnv->_objects ) - 1; i>=0 ; i-- ) {
        if( jk_env_globalEnv->_objects->valueAt( env, jk_env_globalEnv->_objects, i ) == result ) {
            result->objId=i;
            break;
        }
    }
    
    if( strcmp(localName,"")==0 ) {
        /* "" for local name is used as 'default'. Allow "type" as an alias for "type:"
         */
        jk_env_globalEnv->_objects->put( env, jk_env_globalEnv->_objects, result->type, result, NULL );
    }

    return result;
}

/** Define an alias, for simpler config / less typing
 */
static void JK_METHOD jk2_env_alias(jk_env_t *env, const char *name, const char *alias)
{
    jk_bean_t *jkb=env->getBean(env, name);

    if( jkb==NULL ) {
        if( env->l==NULL ) {
            if( env->debug > 0 )
                fprintf(stderr,"env.alias(): Not found %s\n", name);
        } else {
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "env.alias(): Not found %s\n", name);
        }
        return ;
    }

    if( env->debug > 0 ) {
        if( env->l == NULL ) 
            fprintf(stderr,"env.alias(): alias %s %s\n", name, alias);
        else 
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "env.alias(): alias %s %s\n", name, alias);
    }
    
    jk_env_globalEnv->_objects->put( env, jk_env_globalEnv->_objects, alias, jkb, NULL );
}

/** Get the object by name. Returns the real object, not the wrapper
 */
static void * JK_METHOD jk2_env_getByName(jk_env_t *env, const char *name)
{
    jk_bean_t *result=env->getBean( env, name );
        
    if( result==NULL ) {
        if( env->debug > 0 ) {
            if( env->l == NULL ) 
                fprintf(stderr,"env.getByName(): Can't find %#lx %s\n", env, name);
            else 
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "env.getByName(): Can't find %#lx %s\n", env, name);
        }
        return NULL;
    }
    
    if( env->debug > 0 ) {
        if( env->l == NULL ) 
            fprintf(stderr,"env.getByName(): Get by name %s %#lx\n", name, result->object);
        else 
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "env.getByName(): Get by name %s %#lx\n", name, result->object);
    }
    return result->object;
}    

static void* JK_METHOD jk2_env_getByName2(jk_env_t *env, const char *type, const char *localName)
{
    jk_bean_t *result = env->getBean2( env, type, localName);
    if( result==NULL ) return NULL;
    return result->object;
}    

/** Get the wrapper for the named object
 */
static jk_bean_t* JK_METHOD jk2_env_getBean(jk_env_t *env, const char *name)
{
    if( name==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                        "env.getBean(): NullPointerException\n");
        return NULL;
    }

    return (jk_bean_t *)env->_objects->get( env, env->_objects, name );
}    

static jk_bean_t* JK_METHOD jk2_env_getBean2(jk_env_t *env, const char *type, const char *localName)
{
    char *name;
    if( type==NULL || localName==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                        "env.getBean2(): NullPointerException\n");
        return NULL;
    }

    name=env->tmpPool->calloc( env, env->tmpPool, strlen( type ) + strlen( localName ) +2 );
    strcpy(name, type);
    strcat( name,":");
    strcat( name,localName);

    return (jk_bean_t *)env->_objects->get( env, env->_objects, name );
}    

/** Register the type and the factory
 */
static void JK_METHOD jk2_env_registerFactory(jk_env_t *env, 
                                             const char *type,
                                             jk_env_objectFactory_t fact)
{
    if( type==NULL || fact==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "env.registerFactory(): NullPointerException\n");
        return;
    }
    env->_registry->put( env, env->_registry, (char *)type, (void *)fact, NULL );
}

/* -------------------- Exceptions -------------------- */

/* Exceptions.
 */
static void JK_METHOD jkThrow( jk_env_t *env,
                               const char *file, int line,
                               const char *type,
                               const char *fmt, ... )
{
    va_list args;
/*    char *buf; */

    va_start(args, fmt);
    env->l->jkVLog(env, env->l, file, line, JK_LOG_ERROR_LEVEL, fmt, args );
    va_end(args);

}

/** re-throw the exception and record the current pos.
 *  in the stack trace
 *  XXX Not implemented/not used
 */
static void JK_METHOD jkReThrow( jk_env_t *env,
                                 const char *file, int line )
{
    /* Nothing yet. It should record the file/line for stack trace */
}

/* Last exception that occured
 */
static jk_exception_t* JK_METHOD  jk_env_jkException( jk_env_t *env ) 
{
    return env->lastException;
}

/** Clear the exception state
 */
static void JK_METHOD jk_env_jkClearException( jk_env_t *env ) {
    env->lastException=NULL;
}


/* -------------------- Init method -------------------- */


static void jk2_env_initEnv( jk_env_t *env, char *id ) {

    env->registerFactory= jk2_env_registerFactory;
    env->getByName= jk2_env_getByName; 
    env->getByName2= jk2_env_getByName2; 
    env->getBean= jk2_env_getBean; 
    env->getBean2= jk2_env_getBean2; 
    env->createBean2= jk2_env_createBean2;
    env->createBean= jk2_env_createBean;
    env->alias= jk2_env_alias;
    env->getEnv= jk2_env_get; 
    env->recycleEnv= jk2_env_recycleEnv; 
    env->releaseEnv= jk2_env_put; 
    env->debug = 0;
    env->jkClearException=jk_env_jkClearException;
    env->jkException=jk_env_jkException;
    env->getAprPool=jk2_env_getAprPool;
    env->setAprPool=jk2_env_setAprPool;

    env->id=0;
    
    jk2_map_default_create( env, & env->_registry, env->globalPool );
    jk2_map_default_create( env, & env->_objects, env->globalPool );

    env->tmpPool=env->globalPool->create(env, env->globalPool, HUGE_POOL_SIZE);;

    jk2_registry_init(env);
    
    env->envCache= jk2_objCache_create( env, env->globalPool  );
    env->envCache->init( env, env->envCache, 64 );
    env->envCache->maxSize=-1;
}