WebSVN – filter_foundry – Diff – /trunk/telegraphics_common/tt/str.c


/*
    This file is part of a common library
    Copyright (C) 2002-6 Toby Thain, toby@telegraphics.com.au
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
 
#include <string.h>
#include <stdlib.h>
 
#include "str.h"
#include "sprintf_tiny.h"
 
// convert C (null-terminated) to Pascal (length byte) string
// no bounds checking
unsigned char *myc2pstr(char *s){
        size_t n = strlen(s);
        memmove(s+1,s,n);
        *s = (unsigned char)n;
        return (unsigned char*)s;
}
 
// convert Pascal string to C string
// no bounds checking
char *myp2cstr(unsigned char *s){
        int n = *s;
        memmove(s,s+1,n);
        s[n] = 0;
        return (char*)s;
}
 
// copy Pascal string to C string
// no bounds checking
char *myp2cstrcpy(char *dst,const unsigned char *src){
        memcpy(dst,src+1,src[0]);
        dst[src[0]] = 0;
        return dst;
}
 
// copy C string to Pascal string
unsigned char *myc2pstrcpy(unsigned char *dst,const char *src){
        size_t n = strlen(src);
        *dst = n <= 255 ? (unsigned char)n : 255;
        memcpy(dst+1,src,*dst);
        return dst;
}
 
// copy null-terminated string;
// returns pointer after last character copied
char *cat(char *d,char *s){
        while( (*d = *s++) )
                d++;
        return d;
}
 
/*
void *my_memset(void *dst, int val, size_t len){
        char *p;
        for(p=(char*)dst;len--;)
                *p++ = val;
        return dst;
}
*/
 
// my_strdup() is like _strdup(), with the difference that it accepts "char*" instead of "const char*" as argument
char *my_strdup(char *s){
        size_t n = strlen(s);
        char *p = (char*)malloc(n+1);
        if(p)
                memcpy(p,s,n+1);
        return p;
}
 
// DM 03.12.2021 removed, because it is not used in Filter Foundry
/*
unsigned char *PLcstrcpy(unsigned char *s1,const char *s2){
        size_t n = strlen(s2);
        if(n>255)
                n = 255;
        memcpy(s1+1,s2,n);
        *s1 = (unsigned char)n;
        return s1;
}
*/
 
// DM 03.12.2021 removed, because it is not used in Filter Foundry
/*
unsigned char *PLcstrcat(unsigned char * str1,const char * s2){
        size_t n = strlen(s2);
        if(str1[0]+n > 255)
                n = 255 - str1[0];
        memcpy(str1+1+str1[0],s2,n);
        str1[0] += (unsigned char)n;
        return str1;
}
*/
 

Rev 366	Rev 440
1	/*	1	/*
2	This file is part of a common library	2	This file is part of a common library
3	Copyright (C) 2002-6 Toby Thain, toby@telegraphics.com.au	3	Copyright (C) 2002-6 Toby Thain, toby@telegraphics.com.au
4		4
5	This program is free software; you can redistribute it and/or modify	5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by	6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or	7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.	8	(at your option) any later version.
9		9
10	This program is distributed in the hope that it will be useful,	10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.	13	GNU General Public License for more details.
14		14
15	You should have received a copy of the GNU General Public License	15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software	16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/	18	*/
19		19
20	#include <string.h>	20	#include <string.h>
21	#include <stdlib.h>	21	#include <stdlib.h>
22		22
23	#include "str.h"	23	#include "str.h"
24	#include "sprintf_tiny.h"	24	#include "sprintf_tiny.h"
25		25
26	// convert C (null-terminated) to Pascal (length byte) string	26	// convert C (null-terminated) to Pascal (length byte) string
27	// no bounds checking	27	// no bounds checking
28	unsigned char myc2pstr(char s){	28	unsigned char myc2pstr(char s){
29	size_t n = strlen(s);	29	size_t n = strlen(s);
30	memmove(s+1,s,n);	30	memmove(s+1,s,n);
31	*s = (unsigned char)n;	31	*s = (unsigned char)n;
32	return (unsigned char*)s;	32	return (unsigned char*)s;
33	}	33	}
34		34
35	// convert Pascal string to C string	35	// convert Pascal string to C string
36	// no bounds checking	36	// no bounds checking
37	char myp2cstr(unsigned char s){	37	char myp2cstr(unsigned char s){
38	int n = *s;	38	int n = *s;
39	memmove(s,s+1,n);	39	memmove(s,s+1,n);
40	s[n] = 0;	40	s[n] = 0;
41	return (char*)s;	41	return (char*)s;
42	}	42	}
43		43
44	// copy Pascal string to C string	44	// copy Pascal string to C string
45	// no bounds checking	45	// no bounds checking
46	char myp2cstrcpy(char dst,const unsigned char *src){	46	char myp2cstrcpy(char dst,const unsigned char *src){
47	memcpy(dst,src+1,src[0]);	47	memcpy(dst,src+1,src[0]);
48	dst[src[0]] = 0;	48	dst[src[0]] = 0;
49	return dst;	49	return dst;
50	}	50	}
51		51
52	// copy C string to Pascal string	52	// copy C string to Pascal string
53	unsigned char myc2pstrcpy(unsigned char dst,const char *src){	53	unsigned char myc2pstrcpy(unsigned char dst,const char *src){
54	size_t n = strlen(src);	54	size_t n = strlen(src);
55	*dst = n <= 255 ? (unsigned char)n : 255;	55	*dst = n <= 255 ? (unsigned char)n : 255;
56	memcpy(dst+1,src,*dst);	56	memcpy(dst+1,src,*dst);
57	return dst;	57	return dst;
58	}	58	}
59		59
60	// copy null-terminated string;	60	// copy null-terminated string;
61	// returns pointer after last character copied	61	// returns pointer after last character copied
62	char cat(char d,char *s){	62	char cat(char d,char *s){
63	while( (d = s++) )	63	while( (d = s++) )
64	d++;	64	d++;
65	return d;	65	return d;
66	}	66	}
67		67
68	/*	68	/*
69	void my_memset(void dst, int val, size_t len){	69	void my_memset(void dst, int val, size_t len){
70	char *p;	70	char *p;
71	for(p=(char*)dst;len--;)	71	for(p=(char*)dst;len--;)
72	*p++ = val;	72	*p++ = val;
73	return dst;	73	return dst;
74	}	74	}
75	*/	75	*/
76		76
77	// my_strdup() is like _strdup(), with the difference that it accepts "char" instead of "const char" as argument	77	// my_strdup() is like _strdup(), with the difference that it accepts "char" instead of "const char" as argument
78	char my_strdup(char s){	78	char my_strdup(char s){
79	size_t n = strlen(s);	79	size_t n = strlen(s);
80	char p = (char)malloc(n+1);	80	char p = (char)malloc(n+1);
81	if(p)	81	if(p)
82	memcpy(p,s,n+1);	82	memcpy(p,s,n+1);
83	return p;	83	return p;
84	}	84	}
85		85
-		86	// DM 03.12.2021 removed, because it is not used in Filter Foundry
-		87	/*
86	unsigned char PLcstrcpy(unsigned char s1,const char *s2){	88	unsigned char PLcstrcpy(unsigned char s1,const char *s2){
87	size_t n = strlen(s2);	89	size_t n = strlen(s2);
88	if(n>255)	90	if(n>255)
89	n = 255;	91	n = 255;
90	memcpy(s1+1,s2,n);	92	memcpy(s1+1,s2,n);
91	*s1 = (unsigned char)n;	93	*s1 = (unsigned char)n;
92	return s1;	94	return s1;
93	}	95	}
-		96	*/
94		97
-		98	// DM 03.12.2021 removed, because it is not used in Filter Foundry
-		99	/*
95	unsigned char PLcstrcat(unsigned char str1,const char * s2){	100	unsigned char PLcstrcat(unsigned char str1,const char * s2){
96	size_t n = strlen(s2);	101	size_t n = strlen(s2);
97	if(str1[0]+n > 255)	102	if(str1[0]+n > 255)
98	n = 255 - str1[0];	103	n = 255 - str1[0];
99	memcpy(str1+1+str1[0],s2,n);	104	memcpy(str1+1+str1[0],s2,n);
100	str1[0] += (unsigned char)n;	105	str1[0] += (unsigned char)n;
101	return str1;	106	return str1;
102	}	107	}
-		108	*/
103		109

Subversion Repositories filter_foundry

filter_foundry/trunk/telegraphics_common/tt/str.c – Rev 366 → 440