+
+
+/* strncpy() with guaranteed NULL termination. */
+char *strncpyz(char *dest, const char *src, size_t n)
+{
+ assert(n > 0);
+
+ --n;
+ /* paranoia... */
+ if (strlen(src) > n)
+ {
+ fprintf(stderr, "strncpyz prevented buffer overrun!\n");
+ }
+
+ strncpy(dest, src, n);
+ dest[n] = 0;
+ return dest;
+}
+
+/* like strncat() with guaranteed NULL termination
+ * The passed size should be the size of the dest buffer, not the number of
+ * bytes to copy.
+ */
+char *strncatz(char *dest, const char *src, size_t n)
+{
+ size_t maxToCopy;
+ size_t destLen = strlen(dest);
+
+ assert(n > 0);
+ assert(n > destLen);
+
+ maxToCopy = n - destLen - 1;
+
+ /* paranoia... */
+ if (strlen(src) + destLen >= n)
+ {
+ fprintf(stderr, "strncatz prevented buffer overrun!\n");
+ }
+
+ strncat(dest, src, maxToCopy);
+ dest[n - 1] = 0;
+ return dest;
+}
+
+/*-----------------------------------------------------------------*/
+/* getBuildNumber - return build number */
+/*-----------------------------------------------------------------*/
+const char *getBuildNumber(void)
+{
+ return (SDCC_BUILD_NUMBER);
+}
+
+/*-----------------------------------------------------------------*/
+/* getBuildDate - return build date */
+/*-----------------------------------------------------------------*/
+const char *getBuildDate(void)
+{
+ return (__DATE__);
+}
+
+/*-----------------------------------------------------------------*/
+/* getBuildEnvironment - return environment used to build SDCC */
+/*-----------------------------------------------------------------*/
+const char *getBuildEnvironment(void)
+{
+#ifdef __CYGWIN__
+ return "CYGWIN";
+#elif defined __MINGW32__
+ return "MINGW32";
+#elif defined __DJGPP__
+ return "DJGPP";
+#elif defined(_MSC_VER)
+ return "MSVC";
+#elif defined(__BORLANDC__)
+ return "BORLANDC";
+#elif defined(__APPLE__)
+# if defined(__i386__)
+ return "Mac OS X i386";
+# else
+ return "Mac OS X ppc";
+#endif
+#else
+ return "UNIX";
+#endif
+}
+
+#if defined(HAVE_VSNPRINTF) || defined(HAVE_VSPRINTF)
+size_t SDCCsnprintf(char *dst, size_t n, const char *fmt, ...)
+{
+ va_list args;
+ int len;
+
+ va_start(args, fmt);
+
+# if defined(HAVE_VSNPRINTF)
+ len = vsnprintf(dst, n, fmt, args);
+# else
+ vsprintf(dst, fmt, args);
+ len = strlen(dst) + 1;
+# endif
+
+ va_end(args);
+
+ /* on some gnu systems, vsnprintf returns -1 if output is truncated.
+ * In the C99 spec, vsnprintf returns the number of characters that
+ * would have been written, were space available.
+ */
+ if ((len < 0) || (size_t) len >= n) {
+ fprintf(stderr, "internal error: sprintf truncated.\n");
+ }
+
+ return len;
+}
+#endif
+
+/** Pragma tokenizer
+ */
+void
+init_pragma_token(struct pragma_token_s *token)
+{
+ dbuf_init(&token->dbuf, 16);
+ token->type = TOKEN_UNKNOWN;
+}
+
+char *
+get_pragma_token(const char *s, struct pragma_token_s *token)
+{
+ dbuf_set_length(&token->dbuf, 0);
+
+ /* skip leading spaces */
+ while ('\n' != *s && isspace(*s))
+ ++s;
+
+ if ('\0' == *s || '\n' == *s)
+ {
+ token->type = TOKEN_EOL;
+ }
+ else
+ {
+ char *end;
+
+ long val = strtol(s, &end, 0);
+
+ if (end != s && ('\0' == *end || isspace(*end)))
+ {
+ token->val.int_val = val;
+ token->type = TOKEN_INT;
+ dbuf_append(&token->dbuf, s, end - s);
+ s = end;
+ }
+ else
+ {
+ while ('\0' != *s && !isspace(*s))
+ {
+ dbuf_append_char(&token->dbuf, *s);
+ ++s;
+ }
+
+ token->type = TOKEN_STR;
+ }
+ }
+
+ return (char *)s;
+}
+
+const char *
+get_pragma_string(struct pragma_token_s *token)
+{
+ return dbuf_c_str(&token->dbuf);
+}
+
+void
+free_pragma_token(struct pragma_token_s *token)
+{
+ dbuf_destroy(&token->dbuf);
+}
+
+/*! /fn char hexEscape(char **src)
+
+ /param src Pointer to 'x' from start of hex character value
+*/
+
+unsigned char
+hexEscape (const char **src)
+{
+ char *s ;
+ unsigned long value ;
+
+ (*src)++ ; /* Skip over the 'x' */
+
+ value = strtol (*src, &s, 16);
+
+ if (s == *src)
+ {
+ // no valid hex found
+ werror(E_INVALID_HEX);
+ }
+ else
+ {
+ if (value > 255)
+ {
+ werror(W_ESC_SEQ_OOR_FOR_CHAR);
+ }
+ }
+ *src = s;
+
+ return (char) value;
+}
+
+/*------------------------------------------------------------------*/
+/* octalEscape - process an octal constant of max three digits */
+/* return the octal value, throw a warning for illegal octal */
+/* adjust src to point at the last proccesed char */
+/*------------------------------------------------------------------*/
+
+unsigned char
+octalEscape (const char **str)
+{
+ int digits;
+ unsigned value=0;
+
+ for (digits = 0; digits < 3; digits++)
+ {
+ if (**str >='0' && **str <= '7')
+ {
+ value = value*8 + (**str - '0');
+ (*str)++;
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (digits)
+ {
+ if (value > 255 /* || (**str>='0' && **str<='7') */ )
+ {
+ werror (W_ESC_SEQ_OOR_FOR_CHAR);
+ }
+ }
+ return value;
+}
+
+/*!
+ /fn int copyStr (char *dest, char *src)
+
+ Copies a source string to a dest buffer interpreting escape sequences
+ and special characters
+
+ /param dest Buffer to receive the resultant string
+ /param src Buffer containing the source string with escape sequecnes
+ /return Number of characters in output string
+
+*/
+
+int
+copyStr (char *dest, const char *src)
+{
+ char *OriginalDest = dest ;
+
+ while (*src)
+ {
+ if (*src == '\"')
+ src++;
+ else if (*src == '\\')
+ {
+ src++;
+ switch (*src)
+ {
+ case 'n':
+ *dest++ = '\n';
+ break;
+ case 't':
+ *dest++ = '\t';
+ break;
+ case 'v':
+ *dest++ = '\v';
+ break;
+ case 'b':
+ *dest++ = '\b';
+ break;
+ case 'r':
+ *dest++ = '\r';
+ break;
+ case 'f':
+ *dest++ = '\f';
+ break;
+ case 'a':
+ *dest++ = '\a';
+ break;
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ *dest++ = octalEscape(&src);
+ src-- ;
+ break;
+
+ case 'x':
+ *dest++ = hexEscape(&src) ;
+ src-- ;
+ break ;
+
+ case '\\':
+ *dest++ = '\\';
+ break;
+ case '\?':
+ *dest++ = '\?';
+ break;
+ case '\'':
+ *dest++ = '\'';
+ break;
+ case '\"':
+ *dest++ = '\"';
+ break;
+ default:
+ *dest++ = *src;
+ }
+ src++;
+ }
+ else
+ *dest++ = *src++;
+ }
+
+ *dest++ = '\0';
+
+ return dest - OriginalDest ;
+}