%% options copyright owner = Dirk Krause copyright year = 2016-xxxx license = bsd %% header /** @file dk4paper.h Read paper sizes. */ #ifndef DK4CONF_H_INCLUDED #include "dk4conf.h" #endif #ifndef DK4TYPES_H_INCLUDED #include "dk4types.h" #endif #ifndef DK4ERROR_H_INCLUDED #include "dk4error.h" #endif #ifndef DK4STO_H_INCLUDED #include "dk4sto.h" #endif /** One paper size. */ typedef struct { dkChar *name; /**< Paper format name. */ double w; /**< Paper width in PS points. */ double h; /**< Paper height. */ double i; /**< Left or inner border. */ double o; /**< Right or outer border. */ double t; /**< Top border. */ double b; /**< Bottom border. */ } dk4_paper_size_t; /** Collection of paper sizes read from files. */ typedef struct { dk4_sto_t *s_ps; /**< Storage for paper sizes. */ dk4_sto_it_t *i_ps; /**< Iterator through storage. */ } dk4_paper_size_collection_t; #ifdef __cplusplus extern "C" { #endif /** Open a new paper size collection with minimum entries only. @param erp Error report, may be NULL. */ dk4_paper_size_collection_t * dk4papersize_coll_open(dk4_er_t *erp); /** Open a new paper size collection, search for configuration files and apply them. Note: Programs using the dk4_app_t type should use the dk4app_get_paper_sizes() from the dk4papea module instead. @param progname Program name. @param grpname Program group name. @param erp Error report, may be NULL. @return Valid pointer on success, NULL on error. */ dk4_paper_size_collection_t * dk4papersize_coll_for_application( const dkChar *progname, const dkChar *grpname, dk4_er_t *erp ); /** Close paper size collection, release memory. @param ptr Paper size collection to close. */ void dk4papersize_coll_close(dk4_paper_size_collection_t *ptr); /** Find a specific paper size in the collection. Note: Do not mix search and traversal mechanism, use exactly one method from the following three: - Find paper size entry by name using dk4papersize_coll_find(), - Get number of paper sizes using dk4papersize_coll_size() and use dk4papersize_coll_get() to get an entry for a given index, - Reset the collection using dk4papersize_coll_reset() and retrieve the next entry using dk4papersize_coll_next(), repeat dk4papersize_coll_next() until it returns NULL. All three methods use and modify the same internal container iterator, so mixing the methods is not a good idea. @param ptr Paper size collection to search for a paper size. @param name Name of paper size to find. @param erp Error report, may be NULL. @return Pointer to paper size on success, NULL on error or not found. */ const dk4_paper_size_t * dk4papersize_coll_find( dk4_paper_size_collection_t *ptr, const dkChar *name, dk4_er_t *erp ); /** Get number of paper sizes stored in the collection. Note: Do not mix search and traversal mechanism, use exactly one method from the following three: - Find paper size entry by name using dk4papersize_coll_find(), - Get number of paper sizes using dk4papersize_coll_size() and use dk4papersize_coll_get() to get an entry for a given index, - Reset the collection using dk4papersize_coll_reset() and retrieve the next entry using dk4papersize_coll_next(), repeat dk4papersize_coll_next() until it returns NULL. All three methods use and modify the same internal container iterator, so mixing the methods is not a good idea. @param ptr Paper size collection to query. @return Positive number of paper sizes on success, 0 on error. */ size_t dk4papersize_coll_size(dk4_paper_size_collection_t *ptr); /** Get paper size entry from collection by number. Note: Do not mix search and traversal mechanism, use exactly one method from the following three: - Find paper size entry by name using dk4papersize_coll_find(), - Get number of paper sizes using dk4papersize_coll_size() and use dk4papersize_coll_get() to get an entry for a given index, - Reset the collection using dk4papersize_coll_reset() and retrieve the next entry using dk4papersize_coll_next(), repeat dk4papersize_coll_next() until it returns NULL. All three methods use and modify the same internal container iterator, so mixing the methods is not a good idea. @param ptr Paper size collection to query. @param n Index of paper size entry, 0 for the first. @return Valid pointer on success, NULL on error. */ const dk4_paper_size_t * dk4papersize_coll_get(dk4_paper_size_collection_t *ptr, size_t n); /** Reset collection (start traversing at beginning). Note: Do not mix search and traversal mechanism, use exactly one method from the following three: - Find paper size entry by name using dk4papersize_coll_find(), - Get number of paper sizes using dk4papersize_coll_size() and use dk4papersize_coll_get() to get an entry for a given index, - Reset the collection using dk4papersize_coll_reset() and retrieve the next entry using dk4papersize_coll_next(), repeat dk4papersize_coll_next() until it returns NULL. All three methods use and modify the same internal container iterator, so mixing the methods is not a good idea. @param ptr Paper size collection to reset. */ void dk4papersize_coll_reset(dk4_paper_size_collection_t *ptr); /** Get next paper size from collection. Note: Do not mix search and traversal mechanism, use exactly one method from the following three: - Find paper size entry by name using dk4papersize_coll_find(), - Get number of paper sizes using dk4papersize_coll_size() and use dk4papersize_coll_get() to get an entry for a given index, - Reset the collection using dk4papersize_coll_reset() and retrieve the next entry using dk4papersize_coll_next(), repeat dk4papersize_coll_next() until it returns NULL. All three methods use and modify the same internal container iterator, so mixing the methods is not a good idea. @param ptr Paper size collection to query. @return Valid pointer on success, NULL on error or end of collection. */ const dk4_paper_size_t * dk4papersize_coll_next(dk4_paper_size_collection_t *ptr); /** Create a new paper size structure, allocate memory. @param name Name of paper size. @param erp Error report, may be NULL. @return Pointer to new paper size structure on success, NULL on error. */ dk4_paper_size_t * dk4papersize_new(const dkChar *name, dk4_er_t *erp); /** Destroy a paper size structure, release memory. @param pps Paper size structure to destroy. */ void dk4papersize_delete(dk4_paper_size_t *pps); /** Compare two paper sizes. @param l Left object pointer. @param r Right object or name pointer. @param cr Comparison criteria: 0=papersize/papersize, 1=papersize/name. @return Comparison result. */ int dk4papersize_cmp(const void *l, const void *r, int cr); /** Get paper width from paper size record. @param psptr Paper size record to query. @return Positive result on success, negative value on error. */ double dk4papersize_get_width(const dk4_paper_size_t *psptr); /** Get paper height from paper size record. @param psptr Paper size record to query. @return Positive result on success, negative value on error. */ double dk4papersize_get_height(const dk4_paper_size_t *psptr); /** Get left (inner) border from paper size record. @param psptr Paper size record to query. @return Non-negative result on success, negative value on error. */ double dk4papersize_get_left_border(const dk4_paper_size_t *psptr); /** Get right (outer) border from paper size record. @param psptr Paper size record to query. @return Non-negative result on success, negative value on error. */ double dk4papersize_get_right_border(const dk4_paper_size_t *psptr); /** Get top border from paper size record. @param psptr Paper size record to query. @return Non-negative result on success, negative value on error. */ double dk4papersize_get_top_border(const dk4_paper_size_t *psptr); /** Get bottom border from paper size record. @param psptr Paper size record to query. @return Non-negative result on success, negative value on error. */ double dk4papersize_get_bottom_border(const dk4_paper_size_t *psptr); /** Get name for paper size. @param psptr Paper size record to query. @return Valid pointer on success, NULL on error or empty name. */ const dkChar * dk4papersize_get_name(const dk4_paper_size_t *psptr); #ifdef __cplusplus } #endif /* vim: set ai sw=4 ts=4 : */ %% module #include "dk4mem.h" #include "dk4strd.h" #include "dk4paper.h" #include "dk4maiddbl.h" #include "dk4fs.h" #include "dk4mpl.h" #include "dk4tspdk.h" #include "dk4strm.h" #include "dk4strmr.h" #include "dk4enc.h" #include "dk4loc.h" #include "dk4user.h" #include "dk4inst.h" $!trace-include /** Object passed as pointer to the line handler. */ typedef struct { dk4_paper_size_collection_t *coll; /**< Collection to modify. */ } reader_obj_t; /** Configuration files to search for. */ static const dkChar * const conf_file_names[] = { dkT("dk4paper.conf"), dkT("dk3paper.conf") }; /** Default paper size names always defined. */ static const dkChar *default_paper_sizes[] = { $!string-table macro=dkT A4 a4 Letter letter $!end }; void dk4papersize_delete(dk4_paper_size_t *pps) { $? "+ dk4papersize_delete" if (NULL != pps) { $? ". args ok" if (NULL != pps->name) { $? ". name=\"%!ds\"", pps->name $? ". w=%g h=%g l=%g r=%g t=%g, b=%g", pps->w, pps->h, pps->i, pps->o, pps->t, pps->b dk4mem_free(pps->name); pps->name = NULL; } dk4mem_free(pps); } #if TRACE_DEBUG else { $? "! pps" } #endif $? "- dk4papersize_delete" } dk4_paper_size_t * dk4papersize_new(const dkChar *name, dk4_er_t *erp) { dk4_paper_size_t *back = NULL; $? "+ dk4papersize_new \"%!ds\"", TR_STR(name) if (NULL != name) { back = dk4mem_new(dk4_paper_size_t,1,erp); if (NULL != back) { back->w = 0.0; back->h = 0.0; back->i = 0.0; back->o = 0.0; back->t = 0.0; back->b = 0.0; back->name = dk4str_dup(name, erp); if (NULL == back->name) { dk4mem_free(back); back = NULL; } } } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } $? "- dk4papersize_new %d", TR_IPTR(back) return back; } void dk4papersize_coll_close(dk4_paper_size_collection_t *ptr) { dk4_paper_size_t *pps; $? "+ dk4papersize_coll_close %d", TR_IPTR(ptr) if (NULL != ptr) { $? ". ptr ok" if (NULL != ptr->s_ps) { $? ". s_ps ok" if (NULL != ptr->i_ps) { $? ". i_ps ok" dk4sto_it_reset(ptr->i_ps); do { pps = (dk4_paper_size_t *)dk4sto_it_next(ptr->i_ps); if (NULL != pps) { $? ". pps" dk4papersize_delete(pps); } } while (NULL != pps); dk4sto_it_close(ptr->i_ps); ptr->i_ps = NULL; } #if TRACE_DEBUG else { $? "! i_ps" } #endif dk4sto_close(ptr->s_ps); ptr->s_ps = NULL; } #if TRACE_DEBUG else { $? "! s_ps" } #endif $? ". release memory" dk4mem_free(ptr); } #if TRACE_DEBUG else { $? "! ptr" } #endif $? "- dk4papersize_coll_close" } int dk4papersize_cmp(const void *l, const void *r, int cr) { const dk4_paper_size_t *pl = NULL; const dk4_paper_size_t *pr = NULL; const dkChar *nm = NULL; int back = 0; if (NULL != l) { if (NULL != r) { pl = (const dk4_paper_size_t *)l; switch (cr) { case 1 : { nm = (const dkChar *)r; back = dk4str_cmp(pl->name, nm); } break; default : { pr = (const dk4_paper_size_t *)r; back = dk4str_cmp(pl->name, pr->name); } break; } } else { back = 1; } } else { if (NULL != r) { back = -1; } } return back; } static int dk4papersize_i_add_one_default_size( dk4_paper_size_collection_t *pscptr, const dkChar *name, double w, double h, double i, double o, double t, double b, dk4_er_t *erp ) { dk4_paper_size_t *ptr; int back = 0; $? "+ dk4papersize_i_add_one_default_size \"%!ds\"", name ptr = dk4papersize_new(name, erp); if (NULL != ptr) { $? ". ptr" ptr->w = w; ptr->h = h; ptr->i = i; ptr->o = o; ptr->t = t; ptr->b = b; $? ". w = %g", w $? ". h = %g", h $? ". i = %g", i $? ". o = %g", o $? ". t = %g", t $? ". b = %g", b if (0 != dk4sto_add(pscptr->s_ps, ptr, erp)) { back = 1; $? ". add" } else { $? "! add" dk4papersize_delete(ptr); ptr = NULL; } } #if TRACE_DEBUG else { $? "! ptr" } #endif $? "- dk4papersize_i_add_one_default_size %d", back return back; } static int dk4papersize_i_add_default_sizes( dk4_paper_size_collection_t *pscptr, dk4_er_t *erp ) { int back = 0; $? "+ dk4papersize_i_add_default_sizes" back = dk4papersize_i_add_one_default_size( pscptr, default_paper_sizes[0], 595.0, 842.0, 0.0, 0.0, 0.0, 0.0, erp ); if (0 == back) { goto finished; } back = dk4papersize_i_add_one_default_size( pscptr, default_paper_sizes[1], 595.0, 842.0, 56.0, 28.0, 14.0, 14.0, erp ); if (0 == back) { goto finished; } back = dk4papersize_i_add_one_default_size( pscptr, default_paper_sizes[2], 612.0, 792.0, 0.0, 0.0, 0.0, 0.0, erp ); if (0 == back) { goto finished; } back = dk4papersize_i_add_one_default_size( pscptr, default_paper_sizes[3], 612.0, 792.0, 56.0, 28.0, 14.0, 14.0, erp ); if (0 == back) { goto finished; } back = 1; finished: $? "- dk4papersize_i_add_default_sizes %d", back return back; } dk4_paper_size_collection_t * dk4papersize_coll_open(dk4_er_t *erp) { dk4_paper_size_collection_t *back = NULL; int ok = 0; $? "+ dk4papersize_coll_open" back = dk4mem_new(dk4_paper_size_collection_t,1,erp); if (NULL != back) { back->i_ps = NULL; back->s_ps = dk4sto_open(erp); if (NULL != back->s_ps) { (void)dk4sto_set_comp(back->s_ps, dk4papersize_cmp, 0); back->i_ps = dk4sto_it_open(back->s_ps, erp); if (NULL != back->i_ps) { ok = dk4papersize_i_add_default_sizes(back, erp); } } if (0 == ok) { dk4papersize_coll_close(back); back = NULL; } } $? "- dk4papersize_coll_open %d", TR_IPTR(back) return back; } const dk4_paper_size_t * dk4papersize_coll_find( dk4_paper_size_collection_t *ptr, const dkChar *name, dk4_er_t *erp ) { dk4_paper_size_t *back = NULL; $? "+ dk4papersize_coll_find %d \"%!ds\"", TR_IPTR(ptr), TR_STR(name) if ((NULL != ptr) && (NULL != name)) { back = (dk4_paper_size_t *)dk4sto_it_find_like(ptr->i_ps, name, 1); if (NULL == back) { dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND); } } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } $? "- dk4papersize_coll_find %d", TR_IPTR(back) return ((const dk4_paper_size_t *)back); } double dk4papersize_get_width(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->w; } return back; } double dk4papersize_get_height(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->h; } return back; } double dk4papersize_get_left_border(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->i; } return back; } double dk4papersize_get_right_border(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->o; } return back; } double dk4papersize_get_top_border(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->t; } return back; } double dk4papersize_get_bottom_border(const dk4_paper_size_t *psptr) { double back = -1.0; if (NULL != psptr) { back = psptr->b; } return back; } const dkChar * dk4papersize_get_name(const dk4_paper_size_t *psptr) { const dkChar *back = NULL; if (NULL != psptr) { back = psptr->name; } return back; } size_t dk4papersize_coll_size(dk4_paper_size_collection_t *ptr) { size_t back = 0; if (NULL != ptr) { dk4sto_it_reset(ptr->i_ps); while (NULL != dk4sto_it_next(ptr->i_ps)) { back++; } } return back; } void dk4papersize_coll_reset(dk4_paper_size_collection_t *ptr) { if (NULL != ptr) { dk4sto_it_reset(ptr->i_ps); } } const dk4_paper_size_t * dk4papersize_coll_next(dk4_paper_size_collection_t *ptr) { dk4_paper_size_t *back = NULL; if (NULL != ptr) { back = (dk4_paper_size_t *)dk4sto_it_next(ptr->i_ps); } return ((const dk4_paper_size_t *)back); } const dk4_paper_size_t * dk4papersize_coll_get(dk4_paper_size_collection_t *ptr, size_t n) { dk4_paper_size_t *back = NULL; size_t i = 0; if (NULL != ptr) { dk4sto_it_reset(ptr->i_ps); do { back = (dk4_paper_size_t *)dk4sto_it_next(ptr->i_ps); } while ((NULL != back) && (++i <= n)); } return ((const dk4_paper_size_t *)back); } /** Process one input line. @param obj Reader object. @param line Current line to process. @param lineno Line number. @param erp Error report, may be NULL. @return DK4_TSP_RES_OK if processing succeeded, DK4_TSP_RES_ERROR on errors (can continue), DK4_TSP_RES_FATAL on fatal errors (can not continue). */ static int dk4papersize_line_handler( void *obj, dkChar *line, dk4_um_t lineno, dk4_er_t *erp ) { double val[6]; /* w, h, i, o, t, b */ dkChar *tok[16]; /* tokens from the value side */ dk4_paper_size_collection_t *coll; /* collection to complete */ dk4_paper_size_t *ps; /* paper size to modify */ reader_obj_t *rdo; /* reader object */ const dkChar *ep; /* end pointer after double value */ dkChar *pls; /* Line start */ dkChar *pval; /* Start of value side */ size_t ntok; /* number of tokens found */ size_t i; /* traverse tokens */ int back = DK4_TSP_RES_OK; $? "+ dk4papersize_line_handler \"%!ds\"", line /* Retrieve pointers */ rdo = (reader_obj_t *)obj; coll = rdo->coll; /* Find start of line, ignore empty lines */ pls = dk4str_start(line, NULL); if (NULL == pls) { $? ". empty line" goto finished; } /* Ignore comment lines */ if (dkT('#') == *pls) { $? ". comment" goto finished; } /* Find value side */ pval = dk4str_chr(pls, dkT('=')); if (NULL == pval) { /* ERROR: Syntax */ dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); back = DK4_TSP_RES_ERROR; goto finished; } /* Check whether value side contains text */ *(pval++) = dkT('\0'); pval = dk4str_start(pval, NULL); if (NULL == pval) { /* ERROR: Syntax */ dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); back = DK4_TSP_RES_ERROR; goto finished; } /* Check name length */ dk4str_rtwh(pls, NULL); if (0 == dk4str_len(pls)) { /* ERROR: Syntax */ dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); back = DK4_TSP_RES_ERROR; goto finished; } /* Tokenize string */ ntok = dk4str_tokenize(tok, 16, pval, NULL, NULL); if ((2 > ntok) || (6 < ntok)) { /* ERROR: Syntax */ dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); back = DK4_TSP_RES_ERROR; goto finished; } /* Initialize values */ for (i = 0; i < 6; i++) { val[i] = 0.0; } /* Process tokens to values */ for (i = 0; i < ntok; i++) { ep = NULL; if (0 == dk4ma_input_dk_double(&(val[i]), tok[i], &ep, 1, NULL)) { /* ERROR: Syntax */ dk4error_set_simple_error_code(erp, DK4_E_SYNTAX); back = DK4_TSP_RES_ERROR; goto finished; } } /* Modify existing paper size or create a new one */ ps = (dk4_paper_size_t *)dk4sto_it_find_like(coll->i_ps, pls, 1); if (NULL == ps) { ps = dk4papersize_new(pls, NULL); if (NULL != ps) { if (0 == dk4sto_add(coll->s_ps, ps, NULL)) { /* ERROR: Memory */ dk4error_set_simple_error_code( erp, DK4_E_MEMORY_ALLOCATION_FAILED ); dk4papersize_delete(ps); ps = NULL; back = DK4_TSP_RES_FATAL; } } else { /* ERROR: Memory */ dk4error_set_simple_error_code(erp, DK4_E_MEMORY_ALLOCATION_FAILED); back = DK4_TSP_RES_FATAL; } } if (NULL == ps) { goto finished; } ps->w = val[0]; ps->h = val[1]; ps->i = val[2]; ps->o = val[3]; ps->t = val[4]; ps->b = val[5]; finished: $? "- dk4papersize_line_handler %d", back return back; } /** Apply a file to a paper size collection. @param coll Collection to modify. @param fn Configuration file name. @param enc Encoding used in memory. @param erp Error report, may be NULL. @return 1 on success, 0 on errors. */ static int dk4paper_apply_file( dk4_paper_size_collection_t *coll, const dkChar *fn, int enc, dk4_er_t *erp ) { char ib[4096]; dkChar il[1024]; dk4_tspdk_t tsp; reader_obj_t rdo; dk4_stream_t *istrm = NULL; size_t rb = 0; int cc = 1; int res = 0; int back = 1; $? "+ dk4paper_apply_file \"%!ds\"", fn /* Open input stream */ istrm = dk4stream_open_file_reader(fn, erp); if (NULL == istrm) { goto finished; } /* Set up reader structure */ rdo.coll = coll; /* Set up text processing */ res = dk4tspdk_setup_line( &tsp, &rdo, dk4papersize_line_handler, il, DK4_SIZEOF(il,dkChar), enc, ( (DK4_ENCODING_UTF8 == enc) ? (DK4_FILE_ENCODING_UTF8) : (DK4_FILE_ENCODING_ASCII) ), erp ); if (0 == res) { goto finished; } /* Process input file */ res = DK4_TSP_RES_OK; do { $? ". start of loop" cc = 0; rb = sizeof(ib); if (0 != dk4stream_read(ib, &rb, istrm, erp)) { $? ". read ok" if (0 < rb) { $? ". rb ok" res = dk4tspdk_add_bytes(&tsp, (const unsigned char *)ib, rb); if (DK4_TSP_RES_FATAL == res) { $? "! fatal error" back = 0; } else { $? ". processing ok" cc = 1; } } #if TRACE_DEBUG else { $? ". rb = 0" } #endif } #if TRACE_DEBUG else { $? "! read" } #endif $? ". end of loop" } while (1 == cc); /* Finalize text stream processor */ if (DK4_TSP_RES_FATAL != res) { if (DK4_TSP_RES_FATAL == dk4tspdk_finish(&tsp)) { $? "! fatal" back = 0; } } finished: if (NULL != istrm) { dk4stream_close(istrm, NULL); } $? "- dk4paper_apply_file %d", back return back; } dk4_paper_size_collection_t * dk4papersize_coll_for_application( const dkChar *progname, const dkChar *grpname, dk4_er_t *erp ) { dkChar fnb[DK4_MAX_PATH]; /* Construct filename */ dkChar home[DK4_MAX_PATH]; /* User home dir */ dkChar langbuf[16]; /* Language */ dkChar regbuf[16]; /* Region */ dk4_paper_size_collection_t *back = NULL; /* Result */ size_t i; /* File search index */ int enc; /* Encoding */ int res; /* Operation result */ int ok; /* Flag: No error */ $? "+ dk4_paper_size_collection_t" /* Create default collection */ back = dk4papersize_coll_open(erp); if (NULL == back) { $? "! memory" goto finished; } $? ". collection opened" /* Check program and program group name */ if ((NULL == progname) || (NULL == grpname)) { $? "! args" dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); goto finished; } $? ". arguments ok" /* Find users home directory. */ if (0 == dk4user_get_homedir(home, DK4_SIZEOF(home,dkChar), 0, NULL)) { goto finished; } $? ". home = \"%!ds\"", home /* Find encoding */ res = dk4loc_get_settings( langbuf, DK4_SIZEOF(langbuf,dkChar), regbuf, DK4_SIZEOF(regbuf,dkChar), &enc, NULL ); $? ". enc = %d", enc if (0 == res) { enc = DK4_ENCODING_ASCII; } $? ". enc = %d", enc /* Apply configuration files from build-in directory names */ ok = 1; for (i = 0; i <= DK4_FS_CONF_MAX; i++) { #if DK4_HAVE_COMPATDKTOOLS3 res = dk4fs_config_compat_one( fnb, DK4_SIZEOF(fnb,dkChar), conf_file_names[1], dk4inst_get_directory(2), dk4inst_get_directory(1), home, progname, grpname, i, 1, 1, NULL ); if (0 != res) { $? ". apply \"%!ds\"", fnb if (0 == dk4paper_apply_file(back, fnb, enc, erp)) { ok = 0; $? "! failed \"%!ds\"", fnb } } #endif res = dk4fs_config_one( fnb, DK4_SIZEOF(fnb,dkChar), conf_file_names[0], dk4inst_get_directory(2), dk4inst_get_directory(1), home, progname, grpname, i, 1, NULL ); if (0 != res) { $? ". apply \"%!ds\"", fnb if (0 == dk4paper_apply_file(back, fnb, enc, erp)) { ok = 0; $? "! failed \"%!ds\"", fnb } } } if (0 == ok) { $? "! fatal errors" dk4papersize_coll_close(back); back = NULL; } finished: $? "- dk4_paper_size_collection_t %d", TR_IPTR(back) return back; } /* vim: set ai sw=4 ts=4 : */