⇑ Updated
![[3khat16.ico]](../../../img/3khat16.ico)
HP3000
3kMail
![[archive16.gif]](../../../img/archive16.gif "Wayback Archive")
/* csplash.c 05/03/04 nm module -i"-Aa -DMPE" */
/*********************************************************/
/* Copyright (c) 2005 Allegro Consultants, Inc. */
/*********************************************************/
/* NOTE: this must be compiled with 2-byte alignment! */
/* I.e., 32-bit values have to be storable into */
/* memory at addresses that are merely 2-byte */
/* aligned and not 4-byte aligned! */
/* With HP C, that would be "+u2" */
/* */
/*********************************************************/
/* Support modules for converted SPLash! code */
/* */
/* HISTORY */
/* HIST 05/03/04 Added FROM_CSPLASH_C. */
/* HIST 05/03/01 Moved C std includes into csplash.h */
/* HIST Added note about 2-byte alignment. */
/* HIST 04/11/08 Fixed SPLash_scan_while/until for " " */
/* HIST 98/11/03 Added SPLash_cat */
/* HIST 96/02/29 Fixed SPLash_compare_sd */
/*********************************************************/
#define FROM_CSPLASH_C
#include "csplash.h"
#if defined(_WIN32)
/*
assuming MS VC++ compiler
*/
typedef __int16 int16;
typedef __int16 int16_t;
typedef unsigned __int16 uint16;
typedef __int32 int32;
typedef __int32 int32_t;
typedef unsigned __int32 uint32;
#endif
static UINT32 SPLash_masks [] =
{
0x0,
0x1, 0x3, 0x7, 0xf,
0x1f, 0x3f, 0x7f, 0xff,
0x1ff, 0x3ff, 0x7ff, 0xfff,
0x1fff, 0x3fff, 0x7fff, 0xffff,
0x1ffff, 0x3ffff, 0x7ffff, 0xfffff,
0x1fffff, 0x3fffff, 0x7fffff, 0xffffff,
0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff,
0x1fffffff, 0x3fffffff, 0x7fffffff, -1
};
#define int16 int16_t
#define int32 int32_t
/***************************************************************/
void SPLash__set32 (int32 *ptr, int32 val)
{
int16
*dest,
*source;
dest = (int16 *) ptr;
source = (int16 *) &val;
*dest++ = *source++;
*dest++ = *source++;
/* memcpy ( (void *) ptr, (void *) &val;, 4); */
} /* end SPLash__set32 proc */
/***************************************************************/
UINT16 SPLash_cat (UINT16 a, UINT16 b, UINT16 sa, UINT16 sb, UINT16 n)
/* x := a cat b (sa:sb:n) */
/* From HP's SPL->C migration guide */
{
unsigned int
m;
n = 16 - n;
m = (0xfff >> n) << (n - sa);
return ( (UINT16) ( (a & ~m) |
((sa < sb ? b << (sb - sa) : b >> (sa - sb)) & m)));
} /* end SPLash_cat proc */ /* ...SS 981103 */
/***************************************************************/
void SPLash_check_S (void)
{
if (S > 32700)
{
printf ("SPLash! stack overflow, S = %d\n", S);
exit (0);
}
if (S < 0)
{
printf ("SPLash! stack underflow, S = %d\n", S);
exit (0);
}
} /* end SPLash_check_S proc */
/***************************************************************/
INT32 SPLash_compare (void *dst, void *src, INT32 len)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
register INT32
comp_val = 0; /* if len = 0 */
if (len > 0)
{
while (--len >= 0)
if ((comp_val = *(pdst++) - *(psrc++)) != 0)
break;
}
else if (len < 0)
{
while (++len <= 0)
if ((comp_val = *(pdst--) - *(psrc--)) != 0)
break;
}
else
comp_val = 0;
return comp_val;
} /* end SPLash_compare proc */
/***************************************************************/
INT32 SPLash_compare_sd (void *dst, void *src, INT32 len,
INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
register INT32
comp_val = 0; /* if len = 0 */
if (len > 0)
{
while (--len >= 0)
{
if ((comp_val = (*pdst - *psrc)) != 0)
break;
pdst++;
psrc++;
}
}
else if (len < 0)
{
while (++len <= 0)
{
if ((comp_val = (*pdst - *psrc)) != 0)
break;
pdst--;
psrc--;
}
};
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
PUSH_INT16 = len;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 2:
PUSH_ADDRESS = (void *) pdst;
break;
}
return comp_val;
} /* end SPLash_compare_sd proc */
/***************************************************************/
UINT32 SPLash_deposit (UINT32 dst, UINT32 src, INT32 start,
INT32 len)
{
UINT32
mask;
if (start > 31)
return dst;
if (start + len > 32)
len = 32 - start;
src = (src & SPLash_masks [len]) << (32 - start - len);
mask = SPLash_masks [len] << (32 - start - len);
return ((dst & ~mask) | src);
} /* end SPLash_deposit proc */
/***************************************************************/
UINT32 SPLash_extract (UINT32 src, INT32 start, INT32 len)
{
if (start > 31)
return 0;
if (start + len > 32)
len = 32 - start;
return ((src >> (32 - start - len)) & SPLash_masks [len]);
} /* end SPLash_extract proc */
/***************************************************************/
INT32 SPLash_move (void *dst, void *src, INT32 len)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
INT32
orig_len = len;
if (len > 0)
{
if (pdst == psrc + 1)
{
(void) memset (dst, *psrc, len);
pdst += len;
psrc += len;
}
else if (pdst == psrc + 2 && *psrc == psrc [1])
{
(void) memset (dst, *psrc, len);
pdst += len;
psrc += len;
}
else if (abs (pdst - psrc) >= len)
{
(void) memcpy (dst, src, len);
pdst += len;
psrc += len;
}
else
{
while (len-- > 0)
*(pdst++) = *(psrc++);
}
}
else
while (len++ < 0)
*(pdst--) = *(psrc--);
return orig_len;
} /* end SPLash_move proc */
/***************************************************************/
INT32 SPLash_move_a (void *dst, void *src, INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
while (isalpha (*psrc))
*(pdst++) = *(psrc++);
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
break;
}
return (psrc - (unsigned char *) src);
} /* end SPLash_move_a proc */
/***************************************************************/
INT32 SPLash_move_an (void *dst, void *src, INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
while (isalnum (*psrc))
*(pdst++) = *(psrc++);
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
break;
}
return (psrc - (unsigned char *) src);
} /* end SPLash_move_an proc */
/***************************************************************/
INT32 SPLash_move_ans (void *dst, void *src, INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
while (isalnum (*psrc))
*(pdst++) = toupper (*(psrc++));
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
break;
}
return (psrc - (unsigned char *) src);
} /* end SPLash_move_ans proc */
/***************************************************************/
INT32 SPLash_move_as (void *dst, void *src, INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
while (isalpha(*psrc))
*(pdst++) = toupper (*(psrc++));
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
break;
}
return (psrc - (unsigned char *) src);
} /* end SPLash_move_as proc */
/***************************************************************/
INT32 SPLash_move_n (void *dst, void *src, INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
while (isdigit (*psrc))
*(pdst++) = *(psrc++);
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
break;
}
return (psrc - (unsigned char *) src);
} /* end SPLash_move_n proc */
/***************************************************************/
INT32 SPLash_move_sd (void *dst, void *src, INT32 len,
INT32 stack_dec)
{
unsigned char
*pdst = (unsigned char *) dst,
*psrc = (unsigned char *) src;
INT32
orig_len = len;
if (len > 0)
{
if (pdst == psrc + 1)
{
(void) memset (dst, *psrc, len);
pdst += len;
psrc += len;
}
else if (pdst == psrc + 2 && *psrc == psrc [1])
{
(void) memset (dst, *psrc, len);
pdst += len;
psrc += len;
}
else if (abs (pdst - psrc) >= len)
{
(void) memcpy (dst, src, len);
pdst += len;
psrc += len;
}
else
{
while (len-- > 0)
*(pdst++) = *(psrc++);
}
}
else
while (len++ < 0)
*(pdst--) = *(psrc--);
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
PUSH_INT16 = len;
break;
case 1:
PUSH_ADDRESS = (void *) pdst;
PUSH_ADDRESS = (void *) psrc;
break;
case 2:
PUSH_ADDRESS = (void *) pdst;
break;
}
return orig_len;
} /* end SPLash_move_sd proc */
/***************************************************************/
INT32 SPLash_scan_until (void *src, INT16 search_value,
INT32 stack_dec)
{
INT32
end_char,
test_char,
i;
unsigned char
*psrc = (unsigned char *) src;
test_char = search_value & 255;
end_char = (search_value >> 8) & 255;
if (test_char == end_char)
for (i = 0; psrc [i] != test_char; i++)
;
else
for (i = 0; psrc [i] != test_char && psrc [i] != end_char; i++)
;
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) (psrc + i);
PUSH_INT16 = search_value;
break;
case 1:
PUSH_ADDRESS = (void *) (psrc + i);
break;
}
CARRY = (psrc [i] != test_char);
return i;
} /* end SPLash_scan_until proc */
/***************************************************************/
INT32 SPLash_scan_while (void *src, INT16 search_value,
INT32 stack_dec)
{
INT32
end_char,
test_char,
i;
unsigned char
*psrc = (unsigned char *) src;
test_char = search_value & 255;
end_char = (search_value >> 8) & 255;
if (test_char == end_char)
for (i = 0; psrc [i] == test_char; i++)
;
else
for (i = 0; psrc [i] == test_char && psrc [i] != end_char; i++)
;
switch (stack_dec)
{
case 0:
PUSH_ADDRESS = (void *) (psrc + i);
PUSH_INT16 = search_value;
break;
case 1:
PUSH_ADDRESS = (void *) (psrc + i);
break;
}
CARRY = (psrc [i] == end_char);
return i;
} /* end SPLash_scan_while proc */
/***************************************************************/