/* WARNING: This file was generated by dkct. Changes you make here will be lost if dkct is run again! You should modify the original source and run dkct on it. Original source: dk4stt.ctr */ /* Copyright (C) 2015-2017, Dirk Krause Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above opyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the author nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /** @file dk4stt.c The dk4stt module. */ #line 99 "dk4stt.ctr" #include "dk4error.h" #include "dk4mem.h" #include "dk4strd.h" #include "dk4strm.h" #include "dk4stt.h" #include "dk4tspdk.h" #include "dk4enc.h" #line 110 "dk4stt.ctr" void dk4stt_close(dk4_string_table_t *ptr) { dkChar **stptr; size_t nstrings; #line 119 "dk4stt.ctr" if (NULL != ptr) { if (NULL != ptr->strings) { stptr = ptr->strings; nstrings = ptr->nstrings; while (0 < nstrings--) { dk4mem_release(*stptr); stptr++; } dk4mem_release(ptr->strings); } dk4mem_release(ptr->shrtfn); ptr->nstrings = 0; dk4mem_free(ptr); } #line 133 "dk4stt.ctr" } dk4_string_table_t * dk4stt_open(const dkChar *fn, size_t sz, dk4_er_t *erp) { dk4_string_table_t *back = NULL; dkChar **stptr = NULL; int ok = 0; #line 144 "dk4stt.ctr" if ((NULL != fn) && (0 < sz)) { back = dk4mem_new(dk4_string_table_t,1,erp); if (NULL != back) { back->strings = NULL; back->nstrings = 0; back->shrtfn = dk4str_dup(fn, erp); if (NULL != back->shrtfn) { back->nstrings = sz; back->strings = dk4mem_new(DK4_PDKCHAR,sz,erp); if (NULL != back->strings) { stptr = back->strings; while (0 < sz--) { *(stptr++) = NULL; } ok = 1; } } if (1 > ok) { dk4stt_close(back); back = NULL; } } } else { dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS); } #line 167 "dk4stt.ctr" return back; } int dk4stt_compare(const void *l, const void *r, int cr) { int back = 0; const dk4_string_table_t *pl; const dk4_string_table_t *pr; if (NULL != l) { if (NULL != r) { pl = (const dk4_string_table_t *)l; switch (cr) { case 1: { if (NULL != pl->shrtfn) { back = dk4str_cmp(pl->shrtfn, (const dkChar *)r); } else { back = -1; } } break; default: { pr = (const dk4_string_table_t *)r; if (NULL != pl->shrtfn) { if (NULL != pr->shrtfn) { back = dk4str_cmp(pl->shrtfn, pr->shrtfn); } else { back = 1; } } else { if (NULL != pr->shrtfn) { back = -1; } } } break; } } else { back = 1; } } else { if (NULL != r) { back = -1; } } return back; } /** Structure to read a string table from stream. */ typedef struct { dk4_string_table_t *dptr; /**< String table to configure. */ size_t curpos; /**< Current line number. */ } dk4_string_table_reader_t; /** Handler function for text lines. @param obj Object to modify while processing the character. @param line Text line to process. @param lineno Current line number. @param erp Error report, may be NULL. @return DK4_TSP_RES_OK if the character was processed successfully, DK4_TSP_RES_ERROR if there was an error but we can continue, DK4_TSP_RES_FATAL if there was a fatal error so we should abort processing. */ static int dk4stt_line_handler( void *obj, dkChar *line, dk4_um_t lineno, dk4_er_t *erp ) { dk4_string_table_reader_t *reader; /* Reader structure */ #if TRACE_DEBUG dkChar *olcp; /* Original pointer */ #endif dkChar *linecp; /* Copy of line */ int back = DK4_TSP_RES_ERROR; #line 255 "dk4stt.ctr" reader = (dk4_string_table_reader_t *)obj; if (dkT('#') != line[0]) { #line 257 "dk4stt.ctr" if (reader->curpos < reader->dptr->nstrings) { #line 258 "dk4stt.ctr" linecp = dk4str_dup(line, NULL); if (NULL != linecp) { #line 260 "dk4stt.ctr" #if TRACE_DEBUG olcp = linecp; #endif /* Save copy of line to string table */ (reader->dptr->strings)[reader->curpos] = linecp; reader->curpos += 1; back = DK4_TSP_RES_OK; /* Handle backslash escape sequences, remove trailing newline */ while (dkT('\0') != *linecp) { if (dkT('\\') == *linecp) { if (dkT('r') == linecp[1]) { *linecp = dkT('\r'); dk4str_cpy_to_left(&(linecp[1]), &(linecp[2])); } else { if (dkT('n') == linecp[1]) { *linecp = dkT('\n'); dk4str_cpy_to_left(&(linecp[1]), &(linecp[2])); } else { if (dkT('t') == linecp[1]) { *linecp = dkT('\t'); dk4str_cpy_to_left(&(linecp[1]), &(linecp[2])); } else { dk4str_cpy_to_left(linecp, &(linecp[1])); if (dkT('\0') == *linecp) { linecp--; } } } } } else { if (dkT('\n') == *linecp) { *linecp = dkT('\0'); linecp--; } else { if ((dkT('\r') == *linecp) && (dkT('\n') == linecp[1])) { *linecp = dkT('\0'); linecp--; } } } linecp++; } #line 300 "dk4stt.ctr" } else { #line 301 "dk4stt.ctr" /* Not enough memory. */ back = DK4_TSP_RES_FATAL; } } else { #line 305 "dk4stt.ctr" /* More lines than expected, ignore additional lines. */ back = DK4_TSP_RES_OK; } } else { #line 309 "dk4stt.ctr" /* Comment line, no processing required. */ back = DK4_TSP_RES_OK; } #line 312 "dk4stt.ctr" return back; } int dk4stt_apply_stream( dk4_string_table_t *tptr, dk4_stream_t *strm, int pre, dk4_er_t *erp1, dk4_er_t *erp2 ) { dkChar line[1024]; /* Input line buffer */ char buf[4096]; /* Buffer for stream input */ dk4_string_table_reader_t reader; /* Reader structure */ dk4_tspdk_t tspdk; /* Text stream processor */ dk4_er_t e1; /* Error report f decoding */ dk4_er_t e2; /* Error report f processing */ size_t rdb; /* Bytes read */ int cc; /* Flag: Can continue */ int back = 0; #line 336 "dk4stt.ctr" if ((NULL != tptr) && (NULL != strm)) { #line 337 "dk4stt.ctr" dk4error_init(&e1); dk4error_init(&e2); reader.dptr = tptr; reader.curpos = 0; back = dk4tspdk_setup_line( &tspdk, (void *)(&reader), dk4stt_line_handler, line, DK4_SIZEOF(line,dkChar), pre, DK4_FILE_ENCODING_UTF8, &e2 ); if (0 < back) { #line 347 "dk4stt.ctr" #if VERSION_BEFORE_20150821 cc = 1; #endif do { cc = 0; rdb = sizeof(buf); if (0 < dk4stream_read(buf, &rdb, strm, NULL)) { if (0 < rdb) { #line 355 "dk4stt.ctr" switch (dk4tspdk_add_bytes(&tspdk, (unsigned char *)buf, rdb)) { case DK4_TSP_RES_OK: { #line 357 "dk4stt.ctr" cc = 1; } break; case DK4_TSP_RES_ERROR: { #line 360 "dk4stt.ctr" cc = 1; } break; default: { #line 363 "dk4stt.ctr" back = 0; } break; } } else { #line 367 "dk4stt.ctr" } } else { #line 369 "dk4stt.ctr" } } while (cc); if (0 < back) { #line 372 "dk4stt.ctr" if (DK4_TSP_RES_FATAL == dk4tspdk_finish(&tspdk)) { back = 0; #line 374 "dk4stt.ctr" } if (0 < back) { #line 376 "dk4stt.ctr" if (reader.curpos < (reader.dptr)->nstrings) { back = 0; #line 378 "dk4stt.ctr" #line 379 "dk4stt.ctr" #line 380 "dk4stt.ctr" } } } } else { #line 384 "dk4stt.ctr" } } else { #line 386 "dk4stt.ctr" dk4error_set_simple_error_code(erp2, DK4_E_INVALID_ARGUMENTS); } #line 388 "dk4stt.ctr" return back; }