自学教程：C++ HT_OUTOFMEM函数代码示例

PUBLIC HTStream * HTRules (HTRequest *	request,			   void *	param,			   HTFormat	input_format,			   HTFormat	output_format,			   HTStream *	output_stream){    HTAlertCallback *cbf = HTAlert_find(HT_A_CONFIRM);        /*    **  If the library has been compiled so that we automatically accept    **  rule files then it's OK not to ask the user.    */#ifdef HT_AUTOMATIC_RULES    if (!cbf || (cbf && (*cbf)(request,HT_A_CONFIRM, HT_MSG_RULES, NULL,NULL,NULL))) {#else    if ((cbf && (*cbf)(request,HT_A_CONFIRM, HT_MSG_RULES, NULL,NULL,NULL))) {#endif	HTStream * me;	HTTRACE(APP_TRACE, "Rule file... Parser object created/n");	if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)	    HT_OUTOFMEM("HTRules");	me->isa = &HTRuleClass;	me->request = request;	me->buffer = HTChunk_new(512);	me->EOLstate = EOL_BEGIN;	if (!rules) rules = HTList_new();	return me;    } else {	HTRequest_addError(request, ERR_FATAL, NO, HTERR_NO_AUTO_RULES,			   NULL, 0, "HTRules");	return HTErrorStream();    }}/***  Parse a rule file - don't ask don't tell - be carefull with this one!*/PUBLIC HTStream * HTRules_parseAutomatically (HTRequest *	request,					      void *		param,					      HTFormat		input_format,					      HTFormat		output_format,					      HTStream *	output_stream){    if (request) {	HTStream * me;	HTTRACE(APP_TRACE, "Rule file... Automatic parser object created/n");	if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)	    HT_OUTOFMEM("HTRules");	me->isa = &HTRuleClass;	me->request = request;	me->buffer = HTChunk_new(512);	me->EOLstate = EOL_BEGIN;	if (!rules) rules = HTList_new();	return me;    } else {	HTRequest_addError(request, ERR_FATAL, NO, HTERR_NO_AUTO_RULES,			   NULL, 0, "HTRules");	return HTErrorStream();    }}

/*	HTDNS_add**	---------**	Add an element to the cache of visited hosts. Note that this function**	requires the system implemented structure hostent and not our own**	host_info. The homes variable indicates the number of IP addresses **	found. A host name must NOT contain a port number.**	Returns address of new HTdns object*/PUBLIC HTdns * HTDNS_add (HTList * list, struct hostent * element,			  char *host, int *homes){    HTdns *me;    char *addr = NULL;    char **index = element->h_addr_list;    int cnt = 1;    while(*index++) cnt++;    if ((me = (HTdns *) HT_CALLOC(1, sizeof(HTdns))) == NULL ||	(me->addrlist = (char **) HT_CALLOC(1, cnt*sizeof(char*))) == NULL ||	(addr = (char *) HT_CALLOC(1, cnt*element->h_length)) == NULL)	HT_OUTOFMEM("HTDNS_add");    StrAllocCopy(me->hostname, host);    me->ntime = time(NULL);    index = element->h_addr_list;    cnt = 0;    while (*index) {	*(me->addrlist+cnt) = addr+cnt*element->h_length;	memcpy((void *) *(me->addrlist+cnt++), *index++, element->h_length);    }    me->homes = cnt;    *homes = cnt;    if ((me->weight = (double *) HT_CALLOC(me->homes, sizeof(double))) == NULL)        HT_OUTOFMEM("HTDNS_add");    me->addrlength = element->h_length;    HTTRACE(PROT_TRACE, "DNS Add..... `%s/' with %d home(s) to %p/n" _ 		host _ *homes _ list);    HTList_addObject(list, (void *) me);    return me;}

/*	Ensure a certain size**	---------------------*/PUBLIC void HTChunk_ensure (HTChunk * ch, int len){    if (ch && len > 0) {	int needed = ch->size+len;	if (needed >= ch->allocated) {	    ch->allocated = needed - needed%ch->growby + ch->growby;	    if (ch->data) {		if ((ch->data = (char  *) HT_REALLOC(ch->data, ch->allocated)) == NULL)		    HT_OUTOFMEM("HTChunk_ensure");	        memset((void *) (ch->data + ch->size), '/0', ch->allocated-ch->size);	    } else {		if ((ch->data = (char  *) HT_CALLOC(1, ch->allocated)) == NULL)		    HT_OUTOFMEM("HTChunk_ensure");	    }	}    }#if 0    if (needed <= ch->allocated) return;    ch->allocated = needed-1 - ((needed-1) % ch->growby)    			     + ch->growby; /* Round up */    ch->data = ch->data ? (char *)realloc(ch->data, ch->allocated)			: (char *)HT_MALLOC(ch->allocated);    if (ch->data == NULL) HT_OUTOFMEM(__FILE__, "HTChunk_ensure");#endif}

PUBLIC HTMuxChannel * HTMuxChannel_new (HTHost * host){    if (host) {	HTMuxChannel * me = NULL;	/* Create new object */	if ((me = (HTMuxChannel *) HT_CALLOC(1, sizeof(HTMuxChannel))) == NULL)	    HT_OUTOFMEM("HTMuxChannel_new");	me->hash = HTHost_hash(host);	me->host = host;	/*	**  Make sure that we are in interleave mode	*/	HTHost_setMode(host, HT_TP_INTERLEAVE);	/*	**  Get a special MUX Net object that we keep to our selves. We don't	**  associate a request object as the Net object lives longer.	*/	me->net = HTNet_new(NULL);	HTNet_setReadStream(me->net, HTDemux_new(host, me));	/* Insert into hash table */	if (!muxchs) {	    if ((muxchs=(HTList **) HT_CALLOC(HOST_HASH_SIZE, sizeof(HTList *))) == NULL)		HT_OUTOFMEM("HTMuxChannel_new");	}	if (!muxchs[me->hash]) muxchs[me->hash] = HTList_new();	HTList_addObject(muxchs[me->hash], (void *) me);	HTTRACE(MUX_TRACE, "Mux Channel. %p created with hash %d/n" _ me _ me->hash);	return me;    }    return NULL;}

/* C O N S T R U C T O R S */PUBLIC CSParse_t * CSParse_new(void){    CSParse_t * me;	if ((me = (CSParse_t *) HT_CALLOC(1, sizeof(CSParse_t))) == NULL)	    HT_OUTOFMEM("CSParse");    me->nowIn = NowIn_NEEDOPEN;    me->token = HTChunk_new(0x10);	if ((me->pParseContext = (ParseContext_t *) HT_CALLOC(1, sizeof(ParseContext_t))) == NULL)	    HT_OUTOFMEM("ParseContext_t");    return me;}

PUBLIC HText *	LMHText_new (	HTRequest * request,	HTParentAnchor * anchor,	HTStream *outstrm){    HTLine * line;    HText * self;    if ((self = (HText  *) HT_CALLOC(1, sizeof(*self))) == NULL)/*        HT_OUTOFMEM("HText"); */	return self;        self->pLm = Context_getLineMode(request);    if (!loaded_texts) loaded_texts = HTList_new();    HTList_addObject(loaded_texts, self);    if (HTList_count(loaded_texts) >= LOADED_LIMIT) {        HTTRACE(CACHE_TRACE, "MemoryCache. Freeing off cached doc./n");         HText_free((HText *)HTList_removeFirstObject(loaded_texts));    }        if ((line = self->last_line = (HTLine *) HT_MALLOC(LINE_SIZE(MAX_LINE))) == NULL)	HT_OUTOFMEM("HText_New");    line->next = line->prev = line;    line->offset = line->size = 0;    self->lines = self->chars = 0;    self->title = 0;    self->first_anchor = self->last_anchor = self->current_anchor = 0;    self->style = &default_style;    self->top_of_screen = 0;    self->node_anchor = anchor;    self->last_anchor_number = 0;	/* Numbering of them for references */    self->stale = YES;        self->target = NULL;        HTAnchor_setDocument(anchor, (void *) self);    clear_screen();    HTMainText = self;    HTMainAnchor = anchor;    self->display_on_the_fly = DISPLAY_LINES;    self->all_pages = NO;	/* One page at a time on the fly */        if (!space_string) {	/* Make a blank line */        char *p;	if ((space_string = (char  *) HT_MALLOC(HTScreenWidth+1)) == NULL)	    HT_OUTOFMEM("HText_New");        for (p=space_string; p<space_string+HTScreenWidth; p++)             *p = ' '; 		/* Used for printfs later */        space_string[HTScreenWidth] = '/0';     }        return self;}

PUBLIC HTHashtable * HTHashtable_new (int size){    HTHashtable *newHashtable;    int c = size > 0 ? size : HT_L_HASH_SIZE;    if ((newHashtable = (HTHashtable  *) HT_CALLOC(1, sizeof (HTHashtable))) == NULL)        HT_OUTOFMEM("HTHashtable_new");    if((newHashtable->table = (void **) HT_CALLOC(c, sizeof (void *))) == NULL)	HT_OUTOFMEM("HTHashtable_new");    newHashtable->count = 0;    newHashtable->size = c;    return newHashtable;}

PUBLIC HTLink * HTLink_new (void){    HTLink * link;    if ((link = (HTLink *) HT_CALLOC(1, sizeof (HTLink))) == NULL)        HT_OUTOFMEM("HTLink_new");    return link;}

PUBLIC HTStream * HTBoundary   (HTRequest *	request,				void *		param,				HTFormat	input_format,				HTFormat	output_format,				HTStream *	output_stream){    HTResponse * response = HTRequest_response(request);    HTParentAnchor * anchor = HTRequest_anchor(request);    HTAssocList * type_param = response ?	HTResponse_formatParam(response) :	HTAnchor_formatParam(anchor);    char * boundary = HTAssocList_findObject(type_param, "boundary");    if (boundary) {	HTStream * me;	if ((me = (HTStream  *) HT_CALLOC(1, sizeof(HTStream))) == NULL)	    HT_OUTOFMEM("HTBoundary");	me->isa = &HTBoundaryClass;	me->request = request;	me->format = output_format;	me->orig_target = output_stream;	me->debug = HTRequest_debugStream(request);	me->state = EOL_FLF;	StrAllocCopy(me->boundary, boundary);		       /* Local copy */	me->bpos = me->boundary;	HTTRACE(STREAM_TRACE, "Boundary.... Stream created with boundary '%s/'/n" _ me->boundary);	return me;    } else {	HTTRACE(STREAM_TRACE, "Boundary.... UNKNOWN boundary!/n");	return HTErrorStream();    }}

PRIVATE HTNewsNode * HTNewsNode_new (int index, char * subject, char * from,				     time_t date, char * name,				     int refs, HTList * refNames){    HTNewsNode * node;    if ((node = (HTNewsNode *) HT_CALLOC(1, sizeof(HTNewsNode))) == NULL)        HT_OUTOFMEM("HTNewsNode_new");    if (name) StrAllocCopy(node->name, name);    if (subject) {	StrAllocCopy(node->subject, subject);	node->subject = HTStrip(node->subject);    }    if (from) StrAllocCopy(node->from, from);    node->index = index;    node->date = date;    node->refs = refs;    node->refNames = refNames;    node->show = (name != NULL);    node->fake = (name == NULL);    node->minRefIndex = index;    node->maxRefIndex = index;    node->minRefDate = date;    node->maxRefDate = date;    return node;}

/*	Add an entry to a list of host names**	------------------------------------**	Existing entries are replaced with new ones*/PRIVATE BOOL add_hostname (HTList * list, const char * host,			   const char * access, unsigned port,			   BOOL regex, int regex_flags){    HTHostList *me;    if (!list || !host || !*host)	return NO;    if ((me = (HTHostList *) HT_CALLOC(1, sizeof(HTHostList))) == NULL)        HT_OUTOFMEM("add_hostname");#ifdef HT_POSIX_REGEX    if (regex)	me->regex = get_regex_t(host,				regex_flags < 0 ?				W3C_DEFAULT_REGEX_FLAGS : regex_flags);#endif    if (access) {	char *ptr;	StrAllocCopy(me->access, access);      	     	    /* Access method */	ptr = me->access;	while ((*ptr = TOLOWER(*ptr))) ptr++;    }    StrAllocCopy(me->host, host);		     	    	/* Host name */    {	char *ptr = me->host;	while ((*ptr = TOLOWER(*ptr))) ptr++;    }    me->port = port;					      /* Port number */    HTTRACE(PROT_TRACE, "HTHostList.. adding `%s/' to list/n" _ me->host);    HTList_addObject(list, (void *) me);    return YES;}

PRIVATE Robot * Robot_new (void){    Robot * me;    if ((me = (Robot *) HT_CALLOC(1, sizeof(Robot))) == NULL ||	(me->tv = (struct timeval*) HT_CALLOC(1, sizeof(struct timeval))) == NULL)	HT_OUTOFMEM("Robot_new");    me->htext = 0;    me->tv->tv_sec = DEFAULT_TIMEOUT;    me->cwd = HTGetCurrentDirectoryURL();    me->output = OUTPUT;    me->urilist = HTList_new();    me->count = 0;    /* We keep an extra timeout request object for the timeout_handler */    me->timeout = HTRequest_new();    /* Bind the Robot object together with the Request Object */    me->request = HTRequest_new();    HTRequest_setContext (me->request, me);    HTRequest_setPreemptive(me->request, YES);    /* Make a new profile */    HTProfile_newPreemptiveRobot ("w3clibtcl", "1.0");    return me;}

PRIVATE HTChildAnchor * HTChildAnchor_new (void){    HTChildAnchor *child;    if ((child = (HTChildAnchor  *) HT_CALLOC(1, sizeof(HTChildAnchor))) == NULL)        HT_OUTOFMEM("HTChildAnchor_new");    return child;}

PUBLIC int HTServHTTP (SOCKET soc, HTRequest * request){    HTNet * net = HTRequest_net(request);    https_info * http;			    /* Specific protocol information */    /*    ** Initiate a new https object and bind to request object    ** This is actually state HTTPS_BEGIN, but it can't be in the state    ** machine as we need the object first (chicken and egg problem).    */    HTTRACE(PROT_TRACE, "Serv HTTP... on socket %d/n" _ soc);    if ((http = (https_info *) HT_CALLOC(1, sizeof(https_info))) == NULL)        HT_OUTOFMEM("HTServHTTP");    http->server = request;    http->state = HTTPS_BEGIN;    http->clients = HTList_new();    HTNet_setContext(net, http);    /*    ** Create the stream pipe FROM the channel to the server request.    */    net->readStream = HTTPReceive_new(request, http);    HTRequest_setOutputConnected(request, YES);    http->state = HTTPS_BEGIN;    HTNet_setEventCallback(net, ServEvent);    HTNet_setEventParam(net, http);  /* callbacks get http* */    return ServEvent(soc, http, HTEvent_BEGIN);		/* get it started - ops is ignored */}

/*	Define a presentation system command for a content-type**	-------------------------------------------------------** INPUT:**	conversions:	The list of conveters and presenters**	representation:	the MIME-style format name**	command:	the MAILCAP-style command template**	quality:	A degradation faction [0..1]**	maxbytes:	A limit on the length acceptable as input (0 infinite)**	maxsecs:	A limit on the time user will wait (0 for infinity)*/PUBLIC void HTPresentation_add (HTList *	conversions,				const char *	representation,				const char *	command,				const char *	test_command,				double		quality,				double		secs, 				double		secs_per_byte){    HTPresentation * pres;    if (presentation_converter) {	if ((pres = (HTPresentation  *) HT_CALLOC(1,sizeof(HTPresentation))) == NULL)	    HT_OUTOFMEM("HTSetPresentation");        pres->rep = HTAtom_for(representation);	pres->rep_out = WWW_PRESENT;		/* Fixed for now ... :-) */	pres->converter = presentation_converter;	pres->quality = quality;	pres->secs = secs;	pres->secs_per_byte = secs_per_byte;	pres->rep = HTAtom_for(representation);	pres->command = NULL;	StrAllocCopy(pres->command, command);	pres->test_command = NULL;	StrAllocCopy(pres->test_command, test_command);	HTTRACE(CORE_TRACE, "Presentation Adding `%s/' with quality %.2f/n" _ 		    command _ quality);	HTList_addObject(conversions, pres);    }}

PUBLIC char * StrAllocMCopy (char ** dest, ...){    va_list pArgs;    char * p, * argp;    /* How much space do we need? */    int needed = 0;    va_start(pArgs, dest);    while ((p = va_arg(pArgs, char *)) != NULL) 	needed += strlen(p);    va_end(pArgs);    if (*dest) HT_FREE(*dest);    if (needed) {	/* Allocate that amount of memory */	if ((*dest = (char *) HT_MALLOC(needed + 1)) == NULL)	    HT_OUTOFMEM("HTStrCpy");	p = *dest;	/* Fill the string */	va_start(pArgs, dest);	while ((argp = va_arg (pArgs, char *)) != NULL) {	    strcpy(p, argp);	    p += strlen(argp);	}	va_end (pArgs);    }    return *dest;}

/*	HTDir_addElement**	---------------**    	This function accepts a directory line. "data" and "size", and**	"description" can all be NULL**	Returns YES if OK, else NO*/PUBLIC BOOL HTDir_addElement (HTDir *dir, char *name, char *date, char *size,			      HTFileMode mode){    HTDirNode *node = HTDirNode_new();    if (!dir || !name) return NO;    if ((node->fname = (char *) HT_MALLOC(strlen(name) + 2)) == NULL)	HT_OUTOFMEM("HTDir_addElement");    strcpy(node->fname, name);					/* Mandatory */    if (dir->show & HT_DS_DATE && date) StrAllocCopy(node->date, date);    if (dir->show & HT_DS_SIZE && size) StrAllocCopy(node->size, size);    if (dir->show & HT_DS_DES) {#if 0	/* FIND DESCRIPTION */#endif    }    /* Set the mode of the file */    node->mode = mode;    /* Should we display now or later? */    if (dir->key == HT_DK_NONE) {	if (!dir->size++) HTDir_headLine(dir);	HTDirNode_print(dir, node);	HTDirNode_free(node);    } else {	int slen = strlen(name);	if (slen > dir->curfw)	    dir->curfw = slen < MaxFileW ? slen : MaxFileW;	HTArray_addObject(dir->array, (void *) node);    }    return YES;}

/*	String Allocate and Concatenate*/PUBLIC char * HTSACat (char ** dest, const char * src){  if (src && *src) {    if (*dest) {      int length = strlen (*dest);      if ((*dest  = (char  *) HT_REALLOC(*dest, length + strlen(src) + 1)) == NULL)          HT_OUTOFMEM("HTSACat");      strcpy (*dest + length, src);    } else {      if ((*dest  = (char  *) HT_MALLOC(strlen(src) + 1)) == NULL)          HT_OUTOFMEM("HTSACat");      strcpy (*dest, src);    }  }  return *dest;}

PUBLIC HTAlertPar * HTAlert_newReply (void){    HTAlertPar * me;    if ((me = (HTAlertPar  *) HT_CALLOC(1, sizeof(HTAlertPar))) == NULL)        HT_OUTOFMEM("HTAlert_newReply");    return me;}

void HText_beginAnchor (HText * text, HTChildAnchor * anchor){    TextAnchor * a;    if (text && anchor) {	Robot * mr = (Robot *) HTRequest_context(text->request);	HTAnchor * dest = HTAnchor_followMainLink((HTAnchor *) anchor);	HTParentAnchor * dest_parent = HTAnchor_parent(dest);	char * uri = HTAnchor_address((HTAnchor *) dest_parent);#if 0	if (SHOW_MSG) HTTrace("Robot....... Found `%s/' /n", uri ? uri : "NULL");#endif		if (uri) {	    HTList_addObject(mr->urilist, (void *) uri);	    mr->count++;	}	if ((a = (TextAnchor  *) HT_MALLOC(sizeof(*a))) == NULL)	    HT_OUTOFMEM("HText_beginAnchor");	if (text->last_anchor) {	    text->last_anchor->next = a;	} else {	    text->first_anchor = a;	}	a->next = 0;	a->anchor = anchor;	text->last_anchor = a;    	if (HTAnchor_followMainLink((HTAnchor*)anchor)) {	    a->number = ++(text->anchors);	} else {	    a->number = 0;	}    }}

PRIVATE BOOL HTCookieHolder_addCookie (HTRequest * request, HTCookie * cookie){    if (request && cookie) {        HTList * cur = cookie_holder;        HTCookieHolder * pres = NULL;        /* Make sure that we have a cookie holder list */        if (!cookie_holder) cookie_holder = HTList_new();        /* See if we already have a cookie holder for this request */        while ((pres = (HTCookieHolder *) HTList_nextObject(cur))) {            if (pres->request == request) break;        }        /* If found then use existing cookie holder, otherwise create new one */        if (!pres) {            if ((pres = (HTCookieHolder *) HT_CALLOC(1, sizeof(HTCookieHolder))) == NULL)                HT_OUTOFMEM("HTCookieHolder_newCookie");            pres->request = request;            pres->cookies = HTList_new();            /* Add to cookie holder list */            HTList_addObject(cookie_holder, pres);        }        /* Now add the cookie */        HTList_addObject(pres->cookies, cookie);        return YES;    }    return NO;}

void * CSApp_calloc (size_t num, size_t size, const char * file, const char * func){    void * ret;    if ((ret = HT_CALLOC(num, size)) == NULL)        HT_OUTOFMEM(func);    return ret;}

PRIVATE HTCookie * HTCookie_new (void){    HTCookie * me = NULL;    if ((me = (HTCookie *) HT_CALLOC(1, sizeof(HTCookie))) == NULL)        HT_OUTOFMEM("HTCookie_new");    return me;}

/***	Create a sort key node*/PRIVATE HTDirNode * HTDirNode_new (void){    HTDirNode *node;    if ((node = (HTDirNode *) HT_CALLOC(1, sizeof(HTDirNode))) == NULL)        HT_OUTOFMEM("HTDirNode_new");    return node;}

/*	Start an anchor field*/PUBLIC void LMHText_beginAnchor (HText * text,    int elem_num, int attr_num, HTChildAnchor * anc,    const BOOL *present, const char **value){    TextAnchor * a;			/* this is because it's called as link callback */    if (elem_num != HTML_A)	return;    if ((a = (TextAnchor  *) HT_MALLOC(sizeof(*a))) == NULL)        HT_OUTOFMEM("HText_beginAnchor");    a->start = text->chars + text->last_line->size;    a->extent = 0;    if (text->last_anchor) {        text->last_anchor->next = a;    } else {        text->first_anchor = a;    }    a->next = 0;    a->anchor = anc;    text->last_anchor = a;     text->current_anchor = a;        if (HTAnchor_followMainLink((HTAnchor*)anc)) {        a->number = ++(text->last_anchor_number);    } else {        a->number = 0;    }}

/***	Register a Protocol module as an active access method*/PUBLIC BOOL HTProtocol_add (const char *       	name,			    const char *	transport,			    HTProtocolId	protocolId,			    BOOL		preemptive,			    HTProtCallback *	client,			    HTProtCallback *	server){    if (name && (client || server)) {	HTProtocol *newProt;	if ((newProt=(HTProtocol *) HT_CALLOC(1, sizeof(HTProtocol))) == NULL)	    HT_OUTOFMEM("HTProtocol_add");	StrAllocCopy(newProt->name, name);	{	    char *ptr = newProt->name;	    while ((*ptr = TOLOWER(*ptr))) ptr++;	}	StrAllocCopy(newProt->transport, transport);	{	    char *ptr = newProt->transport;	    while ((*ptr = TOLOWER(*ptr))) ptr++;	}	newProt->id = protocolId;	newProt->preemptive = preemptive;	newProt->client = client;	newProt->server = server;	if (!protocols) protocols = HTList_new();	else HTProtocol_delete(name); /* Ensure not listed twice */	HTTRACE(CORE_TRACE, "Protocol.... Adding `%s'/n" _ name);	return HTList_addObject(protocols, (void *) newProt);    }    return NO;}

PUBLIC HTAAModule * HTAA_newModule (const char *	scheme,				    HTNetBefore *	before,				    HTNetAfter *	after,				    HTNetAfter *	update,				    HTUTree_gc *	gc){    if (scheme) {	HTAAModule * pres = find_module(scheme);	/* If found then update entry - else create a new one */	if (!pres) {	    if (!(pres = (HTAAModule *) HT_CALLOC(1, sizeof(HTAAModule))))		HT_OUTOFMEM("HTAA_newModule");	    StrAllocCopy(pres->scheme, scheme);	    pres->before = before;	    pres->after = after;	    pres->update = update;	    pres->gc = gc;	    /* Add the new AA Module to the list */	    HTList_addObject(HTSchemes, (void *) pres);	    HTTRACE(AUTH_TRACE, "Auth Engine. Created module %p/n" _ pres);	} else {	    HTTRACE(AUTH_TRACE, "Auth Engine. Found module %p/n" _ pres);	}	return pres;    } else {	HTTRACE(AUTH_TRACE, "Auth Engine. Bad argument/n");	return NULL;    }}

/*	Structured Text object**	----------------------****	The structured stream can generate either presentation,**	or plain text, or HTML.*/PRIVATE HTStructured * HTML_new (HTRequest *	request,				 void *		param,				 HTFormat	input_format,				 HTFormat	output_format,				 HTStream *	output_stream){    HTStructured * me = NULL;    if (request) {	if ((me = (HTStructured *) HT_CALLOC(1, sizeof(HTStructured))) == NULL)	    HT_OUTOFMEM("HTML_new");	me->isa = &HTMLPresentation;	me->dtd = HTML_dtd();	me->request = request;	me->node_anchor =  HTRequest_anchor(request);	me->title = HTChunk_new(128);	me->comment_start = NULL;	me->comment_end = NULL;	me->target = output_stream;	me->sp = me->stack + MAX_NESTING - 1;	/* Create the text object */	me->text = HTextImp_new(me->request, me->node_anchor, me->target);    }    return me;}

/*	Create a chunk with a certain allocation unit**	--------------*/PUBLIC HTChunk * HTChunk_new (int grow){    HTChunk * ch;    if ((ch = (HTChunk  *) HT_CALLOC(1, sizeof(HTChunk))) == NULL)        HT_OUTOFMEM("HTChunk_new");    ch->growby = grow;    return ch;}

/*	Append a character**	------------------*/PUBLIC void HTChunk_putc (HTChunk * ch, char c){    if (ch) {		if (!ch->data || ch->size >= ch->allocated-1) { /* [SIC] bobr */	    if (ch->data) {		if ((ch->data = (char  *) HT_REALLOC(ch->data,ch->allocated+ch->growby)) == NULL)		    HT_OUTOFMEM("HTChunk_putc");		memset((void *) (ch->data + ch->allocated), '/0', ch->growby);	    } else {		if ((ch->data = (char  *) HT_CALLOC(1, ch->allocated+ch->growby)) == NULL)		    HT_OUTOFMEM("HTChunk_putc");	    }	    ch->allocated += ch->growby;	}	*(ch->data+ch->size++) = c;    }}