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

static uint64_t cephwrap_disk_free(struct vfs_handle_struct *handle,				const struct smb_filename *smb_fname,				uint64_t *bsize,				uint64_t *dfree,				uint64_t *dsize){	struct statvfs statvfs_buf;	int ret;	if (!(ret = ceph_statfs(handle->data, smb_fname->base_name,			&statvfs_buf))) {		/*		 * Provide all the correct values.		 */		*bsize = statvfs_buf.f_bsize;		*dfree = statvfs_buf.f_bavail;		*dsize = statvfs_buf.f_blocks;		DBG_DEBUG("[CEPH] bsize: %llu, dfree: %llu, dsize: %llu/n",			llu(*bsize), llu(*dfree), llu(*dsize));		return *dfree;	} else {		DBG_DEBUG("[CEPH] ceph_statfs returned %d/n", ret);		WRAP_RETURN(ret);	}}

int GWEN_PathManager_FindFile(const char *destLib,                              const char *pathName,                              const char *fileName,                              GWEN_BUFFER *fbuf) {  GWEN_DB_NODE *dbT;  assert(gwen__paths);  dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                       destLib);  if (dbT) {    dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                         pathName);    if (dbT) {      int i;      const char *s;      GWEN_DB_NODE *dbN;      GWEN_BUFFER *tbuf;      tbuf=GWEN_Buffer_new(0, 256, 0, 1);      /* check all paths */      dbN=GWEN_DB_FindFirstGroup(dbT, "pair");      while(dbN) {        for (i=0; ; i++) {          s=GWEN_DB_GetCharValue(dbN, "path", i, 0);          if (!s)            break;          else {            FILE *f;            GWEN_Buffer_AppendString(tbuf, s);            GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);            GWEN_Buffer_AppendString(tbuf, fileName);            DBG_DEBUG(GWEN_LOGDOMAIN, "Trying /"%s/"",                      GWEN_Buffer_GetStart(tbuf));            f=fopen(GWEN_Buffer_GetStart(tbuf), "r");            if (f) {              fclose(f);              DBG_DEBUG(GWEN_LOGDOMAIN,                        "File /"%s/" found in folder /"%s/"",                        fileName,                        s);              GWEN_Buffer_AppendBuffer(fbuf, tbuf);              GWEN_Buffer_free(tbuf);              return 0;            }            GWEN_Buffer_Reset(tbuf);          }        }        dbN=GWEN_DB_FindNextGroup(dbN, "pair");      }      GWEN_Buffer_free(tbuf);    }  }  DBG_INFO(GWEN_LOGDOMAIN, "File /"%s/" not found", fileName);  return GWEN_ERROR_NOT_FOUND;}

static long cephwrap_telldir(struct vfs_handle_struct *handle, DIR *dirp){	long ret;	DBG_DEBUG("[CEPH] telldir(%p, %p)/n", handle, dirp);	ret = ceph_telldir(handle->data, (struct ceph_dir_result *) dirp);	DBG_DEBUG("[CEPH] telldir(...) = %ld/n", ret);	WRAP_RETURN(ret);}

GWEN_XMLNODE *GWEN_XMLNode_Path_Surface(GWEN_XMLNODE_PATH *np) {  if (np->pos==0) {    DBG_DEBUG(GWEN_LOGDOMAIN, "Root reached");    return 0;  }  DBG_DEBUG(GWEN_LOGDOMAIN, "Surfaced to %d", np->pos-1);  return np->nodes[--np->pos];}

static int cephwrap_closedir(struct vfs_handle_struct *handle, DIR *dirp){	int result;	DBG_DEBUG("[CEPH] closedir(%p, %p)/n", handle, dirp);	result = ceph_closedir(handle->data, (struct ceph_dir_result *) dirp);	DBG_DEBUG("[CEPH] closedir(...) = %d/n", result);	WRAP_RETURN(result);}

static int cephwrap_rmdir(struct vfs_handle_struct *handle,			const struct smb_filename *smb_fname){	int result;	DBG_DEBUG("[CEPH] rmdir(%p, %s)/n", handle, smb_fname->base_name);	result = ceph_rmdir(handle->data, smb_fname->base_name);	DBG_DEBUG("[CEPH] rmdir(...) = %d/n", result);	WRAP_RETURN(result);}

static int cephwrap_close(struct vfs_handle_struct *handle, files_struct *fsp){	int result;	DBG_DEBUG("[CEPH] close(%p, %p)/n", handle, fsp);	result = ceph_close(handle->data, fsp->fh->fd);	DBG_DEBUG("[CEPH] close(...) = %d/n", result);	WRAP_RETURN(result);}

static ssize_t cephwrap_pread(struct vfs_handle_struct *handle, files_struct *fsp, void *data,			size_t n, off_t offset){	ssize_t result;	DBG_DEBUG("[CEPH] pread(%p, %p, %p, %llu, %llu)/n", handle, fsp, data, llu(n), llu(offset));	result = ceph_read(handle->data, fsp->fh->fd, data, n, offset);	DBG_DEBUG("[CEPH] pread(...) = %llu/n", llu(result));	WRAP_RETURN(result);}

int AHB_DTAUS__AddNum(GWEN_BUFFER *dst,                      unsigned int size,                      const char *s) {  unsigned int i, j;  assert(dst);  assert(s);  DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding num : %s", s);  i=strlen(s);  if (i>size) {    /* Error out here because e.g. truncated BLZ will lead to failed jobs. */    DBG_ERROR(AQBANKING_LOGDOMAIN, "Number /"%s/" too long: Has length %d but must not be longer than %d characters",	      s, i, size);    return -1;  }  j=size-i;  if (j) {    unsigned int k;    for (k=0; k<j; k++)      GWEN_Buffer_AppendByte(dst, '0');  }  GWEN_Buffer_AppendString(dst, s);  return 0;}

int AHB_DTAUS__AddDtaWord(GWEN_BUFFER *dst,			  unsigned int size,			  const char *s) {  unsigned int i;  unsigned int ssize;  assert(dst);  assert(size);  assert(s);  DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding DTA word: %s", s);  ssize=strlen(s);  if (ssize>size) {    /* Error out here because e.g. truncated accountid will lead to failed jobs. */    DBG_ERROR(AQBANKING_LOGDOMAIN, "Word /"%s/" too long: Has length %d but must not be longer than %d characters",	      s, ssize, size);    return -1;  }  for (i=0; i<size; i++) {    char c;    if (i>=ssize)      c=0;    else      c=s[i];    if (c)      GWEN_Buffer_AppendByte(dst, c);    else      GWEN_Buffer_AppendByte(dst, ' ');  } /* for */  return 0;}

void GWEN_Date__sampleTmplChars(GWEN_UNUSED const GWEN_DATE *t, const char *tmpl,                                GWEN_UNUSED GWEN_BUFFER *buf,                                GWEN_DATE_TMPLCHAR_LIST *ll) {  const char *s;  s=tmpl;  while(*s) {    if (strchr("YMDWw", *s)) {      GWEN_DATE_TMPLCHAR *e;      e=GWEN_Date__findTmplChar(ll, *s);      if (!e) {        /* new entry, create it */        e=GWEN_DateTmplChar_new(*s);        GWEN_DateTmplChar_List_Add(e, ll);      }      assert(e);      e->count++;    }    else {      DBG_DEBUG(GWEN_LOGDOMAIN, "Unknown character in template (%02x)",                *s);    }    s++;  }}

unsigned int Debug_CreateKeyFingerprint(CRYP_RSAKEY *key1) {  IPCMESSAGE *kmsg1;  int ks1;  ERRORCODE err;  const char *ptr1;  unsigned int fp;  kmsg1=IPCMessage_new();  IPCMessage_SetBuffer(kmsg1,0,4096);  err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);  if (!Error_IsOk(err)) {    DBG_ERROR_ERR(err);  }  ks1=IPCMessage_GetMessageSize(kmsg1);  ptr1=IPCMessage_GetMessageBegin(kmsg1);  fp=0;  while(ks1) {    fp+=(unsigned char)(*ptr1);    ptr1++;    ks1--;  } /* while */  IPCMessage_free(kmsg1);  DBG_DEBUG("Fingerprint is: %08x/n",fp);  return fp;}

int GWEN_Directory_FindFileInPaths(const GWEN_STRINGLIST *paths,                                   const char *filePath,                                   GWEN_BUFFER *fbuf) {  GWEN_STRINGLISTENTRY *se;  se=GWEN_StringList_FirstEntry(paths);  while(se) {    GWEN_BUFFER *tbuf;    FILE *f;    tbuf=GWEN_Buffer_new(0, 256, 0, 1);    GWEN_Buffer_AppendString(tbuf, GWEN_StringListEntry_Data(se));    GWEN_Buffer_AppendString(tbuf, DIRSEP);    GWEN_Buffer_AppendString(tbuf, filePath);    DBG_VERBOUS(GWEN_LOGDOMAIN, "Trying /"%s/"",                GWEN_Buffer_GetStart(tbuf));    f=fopen(GWEN_Buffer_GetStart(tbuf), "r");    if (f) {      fclose(f);      DBG_DEBUG(GWEN_LOGDOMAIN,                "File /"%s/" found in folder /"%s/"",                filePath,                GWEN_StringListEntry_Data(se));      GWEN_Buffer_AppendBuffer(fbuf, tbuf);      GWEN_Buffer_free(tbuf);      return 0;    }    GWEN_Buffer_free(tbuf);    se=GWEN_StringListEntry_Next(se);  }  DBG_INFO(GWEN_LOGDOMAIN, "File /"%s/" not found", filePath);  return GWEN_ERROR_NOT_FOUND;}

/* called when a task goes down */static void prefork_terminate(struct tevent_context *ev,			      struct loadparm_context *lp_ctx,			      const char *reason,			      void *process_context){	DBG_DEBUG("called with reason[%s]/n", reason);}

static int streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,			       SMB_STRUCT_STAT *sbuf){	struct smb_filename *smb_fname_base = NULL;	int ret = -1;	struct stream_io *io = (struct stream_io *)		VFS_FETCH_FSP_EXTENSION(handle, fsp);	if (io == NULL || fsp->base_fsp == NULL) {		return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);	}	DBG_DEBUG("streams_xattr_fstat called for %s/n", fsp_str_dbg(io->fsp));	if (!streams_xattr_recheck(io)) {		return -1;	}	/* Create an smb_filename with stream_name == NULL. */	smb_fname_base = synthetic_smb_fname(talloc_tos(),					io->base,					NULL,					NULL,					fsp->fsp_name->flags);	if (smb_fname_base == NULL) {		errno = ENOMEM;		return -1;	}	if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {		ret = SMB_VFS_LSTAT(handle->conn, smb_fname_base);	} else {		ret = SMB_VFS_STAT(handle->conn, smb_fname_base);	}	*sbuf = smb_fname_base->st;	if (ret == -1) {		TALLOC_FREE(smb_fname_base);		return -1;	}	sbuf->st_ex_size = get_xattr_size(handle->conn,					smb_fname_base, io->xattr_name);	if (sbuf->st_ex_size == -1) {		TALLOC_FREE(smb_fname_base);		SET_STAT_INVALID(*sbuf);		return -1;	}	DEBUG(10, ("sbuf->st_ex_size = %d/n", (int)sbuf->st_ex_size));	sbuf->st_ex_ino = stream_inode(sbuf, io->xattr_name);	sbuf->st_ex_mode &= ~S_IFMT;	sbuf->st_ex_mode &= ~S_IFDIR;        sbuf->st_ex_mode |= S_IFREG;        sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;	TALLOC_FREE(smb_fname_base);	return 0;}

static int cephwrap_statvfs(struct vfs_handle_struct *handle,				const struct smb_filename *smb_fname,				vfs_statvfs_struct *statbuf){	struct statvfs statvfs_buf;	int ret;	ret = ceph_statfs(handle->data, smb_fname->base_name, &statvfs_buf);	if (ret < 0) {		WRAP_RETURN(ret);	} else {		statbuf->OptimalTransferSize = statvfs_buf.f_frsize;		statbuf->BlockSize = statvfs_buf.f_bsize;		statbuf->TotalBlocks = statvfs_buf.f_blocks;		statbuf->BlocksAvail = statvfs_buf.f_bfree;		statbuf->UserBlocksAvail = statvfs_buf.f_bavail;		statbuf->TotalFileNodes = statvfs_buf.f_files;		statbuf->FreeFileNodes = statvfs_buf.f_ffree;		statbuf->FsIdentifier = statvfs_buf.f_fsid;		DBG_DEBUG("[CEPH] f_bsize: %ld, f_blocks: %ld, f_bfree: %ld, f_bavail: %ld/n",			(long int)statvfs_buf.f_bsize, (long int)statvfs_buf.f_blocks,			(long int)statvfs_buf.f_bfree, (long int)statvfs_buf.f_bavail);	}	return ret;}

static struct dirent *cephwrap_readdir(struct vfs_handle_struct *handle,				       DIR *dirp,				       SMB_STRUCT_STAT *sbuf){	struct dirent *result;	DBG_DEBUG("[CEPH] readdir(%p, %p)/n", handle, dirp);	result = ceph_readdir(handle->data, (struct ceph_dir_result *) dirp);	DBG_DEBUG("[CEPH] readdir(...) = %p/n", result);	/* Default Posix readdir() does not give us stat info.	 * Set to invalid to indicate we didn't return this info. */	if (sbuf)		SET_STAT_INVALID(*sbuf);	return result;}

static void cephwrap_disconnect(struct vfs_handle_struct *handle){	int ret;	if (!cmount) {		DBG_ERR("[CEPH] Error, ceph not mounted/n");		return;	}	/* Should we unmount/shutdown? Only if the last disconnect? */	if (--cmount_cnt) {		DBG_DEBUG("[CEPH] Not shuting down CEPH because still more connections/n");		return;	}	ret = ceph_unmount(cmount);	if (ret < 0) {		DBG_ERR("[CEPH] failed to unmount: %s/n", strerror(-ret));	}	ret = ceph_release(cmount);	if (ret < 0) {		DBG_ERR("[CEPH] failed to release: %s/n", strerror(-ret));	}	cmount = NULL;  /* Make it safe */}

int GWEN_Process_Redirect(GWEN_PROCESS *pr){  assert(pr);  pr->filesStdin[0]=-1;  pr->filesStdout[0]=-1;  pr->filesStderr[0]=-1;  if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDIN) {    int filedes[2];    DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stdin");    if (pipe(filedes)) {      DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));      return -1;    }    pr->filesStdin[0]=filedes[1];    pr->filesStdin[1]=filedes[0];  }  if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDOUT) {    int filedes[2];    DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stdout");    if (pipe(filedes)) {      DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));      return -1;    }    pr->filesStdout[0]=filedes[0];    pr->filesStdout[1]=filedes[1];  }  if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDERR) {    int filedes[2];    DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stderr");    if (pipe(filedes)) {      DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));      return -1;    }    pr->filesStderr[0]=filedes[0];    pr->filesStderr[1]=filedes[1];  }  return 0;}

static int cephwrap_open(struct vfs_handle_struct *handle,			struct smb_filename *smb_fname,			files_struct *fsp, int flags, mode_t mode){	int result = -ENOENT;	DBG_DEBUG("[CEPH] open(%p, %s, %p, %d, %d)/n", handle,		  smb_fname_str_dbg(smb_fname), fsp, flags, mode);	if (smb_fname->stream_name) {		goto out;	}	result = ceph_open(handle->data, smb_fname->base_name, flags, mode);out:	DBG_DEBUG("[CEPH] open(...) = %d/n", result);	WRAP_RETURN(result);}

int EBC_Provider_GenerateTimeStamp(GWEN_UNUSED AB_PROVIDER *pro,				   AB_USER *u,				   GWEN_BUFFER *buf) {  char timestamp[40];  time_t ti;  struct tm *t;  ti=time(0);  /*  if (EBC_User_GetFlags(u) & EBC_USER_FLAGS_TIMESTAMP_FIX1) {  */    t=gmtime(&ti);    snprintf(timestamp, sizeof(timestamp)-1,	     "%04d-%02d-%02dT%02d:%02d:%02d.000Z",	     t->tm_year+1900,	     t->tm_mon+1,	     t->tm_mday,	     t->tm_hour,	     t->tm_min,	     t->tm_sec);    timestamp[sizeof(timestamp)-1]=0;    DBG_DEBUG(AQEBICS_LOGDOMAIN,	      "Generated timestamp [%s]",	      timestamp);    GWEN_Buffer_AppendString(buf, timestamp);  /*  }  else {    int thzone;    t=localtime(&ti);    thzone=-timezone/60;    if (t->tm_isdst>0)      thzone+=60;    snprintf(timestamp, sizeof(timestamp)-1,	     "%04d-%02d-%02dT%02d:%02d:%02d.000%+03d:%02d",	     t->tm_year+1900,	     t->tm_mon+1,	     t->tm_mday,	     t->tm_hour,	     t->tm_min,	     t->tm_sec,	     (int)(thzone/60),	     abs(thzone%60));    timestamp[sizeof(timestamp)-1]=0;    DBG_DEBUG(AQEBICS_LOGDOMAIN,	      "Generated timestamp [%s] (tz=%d, daylight=%d)",	      timestamp, (int)timezone, t->tm_isdst);    GWEN_Buffer_AppendString(buf, timestamp);  }  */  return 0;}

void GWEN_Process_SignalHandler(int s){  int status;  pid_t pid;  switch (s) {  case SIGCHLD:    /* try to get the status */    pid=waitpid(0, &status, WNOHANG);    if (pid==-1) {      DBG_DEBUG(GWEN_LOGDOMAIN, "waitdpid(%d): %s", 0, strerror(errno));    }    else if (pid==0) {      /* process still running ?! */      DBG_DEBUG(GWEN_LOGDOMAIN, "Got a SIGCHLD but no child terminated ??");    }    else {      GWEN_PROCESS *pr;      /* som process terminated */      pr=GWEN_Process_FindProcess(pid);      if (!pr) {        DBG_NOTICE(GWEN_LOGDOMAIN, "No infomation about process /"%d/" available", (int)pid);      }      else {        GWEN_Process_MakeState(pr, status);        /* remove from list. If this process data is not used by the         * aplication it will now be freed, otherwise only the usage         * counter is decremented */        GWEN_Process_free(pr);      }    }    break;  default:    DBG_ERROR(GWEN_LOGDOMAIN, "Got unhandled signal /"%d/"", s);    break;  } /* switch */}

int GWEN_LibLoader_LoadLibrary(GWEN_LIBLOADER *h,                               const char *name){  const char *errorstring;  assert(h);  DBG_DEBUG(GWEN_LOGDOMAIN, "Loading library /"%s/"", name);  h->handle=dlopen(name, RTLD_LAZY);  if (!h->handle) {#ifdef ENABLE_NLS    const char *orig_locale = setlocale(LC_MESSAGES, NULL);    char *currentLocale = strdup(orig_locale ? orig_locale : "C");    setlocale(LC_MESSAGES, "C");#endif    /* The string is checked against the known "C" locale strings       below. We *have* to switch to the C locale temporarily because       otherwise the string might be any translated value. */    errorstring = dlerror();#ifdef ENABLE_NLS    setlocale(LC_MESSAGES, currentLocale);    free(currentLocale);#endif    DBG_INFO(GWEN_LOGDOMAIN, "dlopen(%s): %s", name, errorstring);    if (strstr(errorstring, "No such file")) {      if (strstr(errorstring, name)) {        return GWEN_ERROR_NOT_FOUND;      }    }    else if (strstr(errorstring, "undefined symbol:")) {      DBG_INFO(GWEN_LOGDOMAIN,               "GWEN: Error loading library: %s",               errorstring);      if (strstr(errorstring, name))        return GWEN_ERROR_COULD_NOT_RESOLVE;      else        return GWEN_ERROR_COULD_NOT_LOAD;    }    DBG_INFO(GWEN_LOGDOMAIN,             "GWEN: Error loading library: %s",             errorstring);    return GWEN_ERROR_COULD_NOT_LOAD;  }  DBG_INFO(GWEN_LOGDOMAIN, "Loaded library /"%s/"", name);  return 0;}

int GWEN_PathManager_GetMatchingFilesRecursively(const char *destLib,    const char *pathName,    const char *subFolderName,    GWEN_STRINGLIST *sl,    const char *mask) {  GWEN_DB_NODE *dbT;  assert(gwen__paths);  dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                       destLib);  if (dbT) {    dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                         pathName);    if (dbT) {      int i;      const char *s;      GWEN_DB_NODE *dbN;      GWEN_BUFFER *tbuf;      tbuf=GWEN_Buffer_new(0, 256, 0, 1);      /* check all paths */      dbN=GWEN_DB_FindFirstGroup(dbT, "pair");      while(dbN) {        for (i=0; ; i++) {          s=GWEN_DB_GetCharValue(dbN, "path", i, 0);          if (!s)            break;          else {            GWEN_Buffer_AppendString(tbuf, s);            if (subFolderName && *subFolderName) {              GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);              GWEN_Buffer_AppendString(tbuf, subFolderName);            }            DBG_DEBUG(GWEN_LOGDOMAIN, "Trying /"%s/"",                      GWEN_Buffer_GetStart(tbuf));            GWEN_Directory_GetMatchingFilesRecursively(GWEN_Buffer_GetStart(tbuf), sl, mask);            GWEN_Buffer_Reset(tbuf);          }        }        dbN=GWEN_DB_FindNextGroup(dbN, "pair");      }      GWEN_Buffer_free(tbuf);    }  }  return 0;}

const char *GWEN_XMLNode_GetLocalizedCharValue(const GWEN_XMLNODE *n,					       const char *name,					       const char *defValue) {  GWEN_XMLNODE *nn=0;  GWEN_STRINGLIST *langl;  langl=GWEN_I18N_GetCurrentLocaleList();  if (langl) {    GWEN_STRINGLISTENTRY *se;    se=GWEN_StringList_FirstEntry(langl);    while(se) {      const char *l;      l=GWEN_StringListEntry_Data(se);      DBG_DEBUG(GWEN_LOGDOMAIN, "Trying locale /"%s/"", l);      assert(l);      nn=GWEN_XMLNode_FindFirstTag(n, name, "lang", l);      while(nn) {        GWEN_XMLNODE *dn;        dn=GWEN_XMLNode_GetFirstData(nn);        if (dn) {          if (dn->data && *(dn->data))            return dn->data;        }        nn=GWEN_XMLNode_FindNextTag(nn, name, "lang", l);      } /* while nn */      se=GWEN_StringListEntry_Next(se);    } /* while */  } /* if language list available */  /* otherwise try without locale */  nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);  while(nn) {    GWEN_XMLNODE *dn;    dn=GWEN_XMLNode_GetFirstData(nn);    if (dn) {      if (dn->data)        return dn->data;    }    nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);  }  return defValue;}

FXFont *FOX16_HtmlCtx::_getFoxFont(HTML_FONT *fnt) {  FXFont *xfnt;  if (GWEN_INHERIT_ISOFTYPE(HTML_FONT, FXFont, fnt)) {    xfnt=GWEN_INHERIT_GETDATA(HTML_FONT, FXFont, fnt);    return xfnt;  }  else {    FXuint size;    FXuint weight;    FXuint slant;    FXuint encoding;    FXString face;    uint32_t flags;    if (HtmlFont_GetFontName(fnt))      face=HtmlFont_GetFontName(fnt);    else      face=_font->getName();    size=HtmlFont_GetFontSize(fnt);    weight=FXFont::Normal;    slant=_font->getSlant();    encoding=_font->getEncoding();    flags=HtmlFont_GetFontFlags(fnt);    if (flags & HTML_FONT_FLAGS_STRONG)      weight=FXFont::Bold;    if (flags & HTML_FONT_FLAGS_ITALIC)      slant=FXFont::Italic;    DBG_DEBUG(GWEN_LOGDOMAIN,              "Creating font [%s], size=%d, weight=%d, slant=%d, encoding=%d",              face.text(), size, weight, slant, encoding);    xfnt=new FXFont(FXApp::instance(), face, size, weight, slant, encoding);    if (xfnt==NULL) {      DBG_ERROR(GWEN_LOGDOMAIN,                "Could not create font [%s], size=%d, weight=%d, slant=%d, encoding=%d",                face.text(), size, weight, slant, encoding);      return NULL;    }    xfnt->create();    GWEN_INHERIT_SETDATA(HTML_FONT, FXFont, fnt, xfnt,                         FOX16_HtmlCtxLinker::freeFontData);    return xfnt;  }}

int GWEN_XMLNode_Path_Dive(GWEN_XMLNODE_PATH *np,                           GWEN_XMLNODE *n) {  unsigned int i;  if (np->pos>=GWEN_XML_MAX_DEPTH) {    DBG_ERROR(GWEN_LOGDOMAIN, "Path too deep");    return 1;  }  /* check for double entries */  for (i=0; i<np->pos; i++) {    assert(np->nodes[i]!=n);  }  np->nodes[np->pos++]=n;  DBG_DEBUG(GWEN_LOGDOMAIN, "Dived to %d", np->pos);  return 0;}

int Debug_CompareKeys(CRYP_RSAKEY *key1, CRYP_RSAKEY *key2) {  IPCMESSAGE *kmsg1, *kmsg2;  int ks1, ks2;  ERRORCODE err;  kmsg1=IPCMessage_new();  IPCMessage_SetBuffer(kmsg1,0,4096);  kmsg2=IPCMessage_new();  IPCMessage_SetBuffer(kmsg2,0,4096);  err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);  if (!Error_IsOk(err)) {    DBG_ERROR_ERR(err);  }  err=Cryp_RsaKey_ToMessage(key2, kmsg2, 1);  if (!Error_IsOk(err)) {    DBG_ERROR_ERR(err);  }  ks1=IPCMessage_GetMessageSize(kmsg1);  ks2=IPCMessage_GetMessageSize(kmsg2);  DBG_DEBUG("Sizes: Key1=%d, Key2=%d/n",ks1, ks2);  if (ks1==ks2) {    const char *ptr1, *ptr2;    ptr1=IPCMessage_GetMessageBegin(kmsg1);    ptr2=IPCMessage_GetMessageBegin(kmsg2);    while(ks1) {      if (*ptr1!=*ptr2) {	DBG_ERROR("Keys differ !/n");	break;	ptr1++;	ptr2++;        ks1--;      }    } /* while */  }  IPCMessage_free(kmsg1);  IPCMessage_free(kmsg2);  if (!ks1)    return 0;  else    return 1;}