41 //#endif |
41 //#endif |
42 //} |
42 //} |
43 |
43 |
44 string255 fpcrtl_strconcat(string255 str1, string255 str2) |
44 string255 fpcrtl_strconcat(string255 str1, string255 str2) |
45 { |
45 { |
46 //printf("str1 = %d, %d\n", str1.len, strlen(str1.str)); |
46 int newlen = str1.len + str2.len; |
47 //printf("str2 = %d, %d\n", str2.len, strlen(str2.str)); |
47 if(newlen > 255) newlen = 255; |
48 |
48 |
49 #ifdef FPCRTL_DEBUG |
49 memcpy(&(str1.str[str1.len]), str2.str, newlen - str1.len); |
50 if(str1.len + (int)(str2.len) > 255){ |
50 str1.len = newlen; |
51 printf("String overflow\n"); |
|
52 printf("str1(%d): %s\nstr2(%d): %s\n", str1.len, str1.str, str2.len, str2.str); |
|
53 printf("String will be truncated.\n"); |
|
54 |
|
55 strbuf[0] = 0; |
|
56 strcpy(strbuf, str1.str); |
|
57 strcat(strbuf, str2.str); |
|
58 memcpy(str1.str, strbuf, 255); |
|
59 str1.str[254] = 0; |
|
60 |
|
61 return str1; |
|
62 } |
|
63 #endif |
|
64 |
|
65 memcpy(&(str1.str[str1.len]), str2.str, str2.len); |
|
66 str1.str[str1.len + str2.len] = 0; |
|
67 str1.len += str2.len; |
|
68 |
51 |
69 return str1; |
52 return str1; |
70 } |
53 } |
71 |
54 |
|
55 astring fpcrtl_strconcatA(astring str1, astring str2) |
|
56 { |
|
57 int newlen = str1.len + str2.len; |
|
58 if(newlen > MAX_ANSISTRING_LENGTH) newlen = MAX_ANSISTRING_LENGTH; |
|
59 |
|
60 memcpy(&(str1.s[str1.len + 1]), str2.s[1], newlen - str1.len); |
|
61 str1.len = newlen; |
|
62 |
|
63 return str1; |
|
64 } |
|
65 |
72 string255 fpcrtl_strappend(string255 s, char c) |
66 string255 fpcrtl_strappend(string255 s, char c) |
73 { |
67 { |
74 s.str[s.len] = c; |
68 if(s.len < 255) |
75 s.str[s.len + 1] = 0; |
69 { |
76 s.len ++; |
70 s.s[s.len] = c; |
|
71 ++s.len; |
|
72 } |
77 |
73 |
78 return s; |
74 return s; |
79 } |
75 } |
80 |
76 |
|
77 astring fpcrtl_strappendA(astring s, char c) |
|
78 { |
|
79 if(s.len < MAX_ANSISTRING_LENGTH) |
|
80 { |
|
81 s.s[s.len] = c; |
|
82 ++s.len; |
|
83 } |
|
84 |
|
85 return s; |
|
86 } |
|
87 |
81 string255 fpcrtl_strprepend(char c, string255 s) |
88 string255 fpcrtl_strprepend(char c, string255 s) |
82 { |
89 { |
83 FIX_STRING(s); |
90 uint8_t newlen = s.len < 255 ? s.len + 1 : 255; |
84 |
91 memmove(s.str + 1, s.str, newlen); // also move '/0' |
85 memmove(s.str + 1, s.str, s.len + 1); // also move '/0' |
|
86 s.str[0] = c; |
92 s.str[0] = c; |
87 s.len++; |
93 s.len = newlen; |
88 |
94 |
89 return s; |
95 return s; |
90 } |
96 } |
91 |
97 |
92 string255 fpcrtl_chrconcat(char a, char b) |
98 string255 fpcrtl_chrconcat(char a, char b) |
94 string255 result; |
100 string255 result; |
95 |
101 |
96 result.len = 2; |
102 result.len = 2; |
97 result.str[0] = a; |
103 result.str[0] = a; |
98 result.str[1] = b; |
104 result.str[1] = b; |
99 result.str[2] = 0; |
|
100 |
105 |
101 return result; |
106 return result; |
102 } |
107 } |
103 |
108 |
104 bool fpcrtl_strcompare(string255 str1, string255 str2) |
109 bool fpcrtl_strcompare(string255 str1, string255 str2) |
105 { |
110 { |
106 //printf("str1 = %d, %d\n", str1.len, strlen(str1.str)); |
111 if(strncmp(str1.str, str2.str, 256) == 0){ |
107 //printf("str2 = %d, %d\n", str2.len, strlen(str2.str)); |
|
108 FIX_STRING(str1); |
|
109 FIX_STRING(str2); |
|
110 |
|
111 if(strcmp(str1.str, str2.str) == 0){ |
|
112 return true; |
112 return true; |
113 } |
113 } |
114 |
114 |
115 return false; |
115 return false; |
116 } |
116 } |
117 |
117 |
118 bool fpcrtl_strcomparec(string255 a, char b) |
118 bool fpcrtl_strcomparec(string255 a, char b) |
119 { |
119 { |
120 FIX_STRING(a); |
|
121 |
|
122 if(a.len == 1 && a.str[0] == b){ |
120 if(a.len == 1 && a.str[0] == b){ |
123 return true; |
121 return true; |
124 } |
122 } |
125 |
123 |
126 return false; |
124 return false; |
129 bool fpcrtl_strncompare(string255 a, string255 b) |
127 bool fpcrtl_strncompare(string255 a, string255 b) |
130 { |
128 { |
131 return !fpcrtl_strcompare(a, b); |
129 return !fpcrtl_strcompare(a, b); |
132 } |
130 } |
133 |
131 |
134 //char* fpcrtl_pchar(string255 s) |
132 bool fpcrtl_strncompareA(astring a, astring b) |
135 //{ |
133 { |
136 // return s.str; |
134 return (a.len == b.len) && (strncmp(a.s, b.s, MAX_ANSISTRING_LENGTH) == 0); |
137 //} |
135 } |
138 |
136 |
139 string255 fpcrtl_pchar2str(char *s) |
137 |
|
138 string255 fpcrtl_pchar2str(const char *s) |
140 { |
139 { |
141 string255 result; |
140 string255 result; |
142 int t = strlen(s); |
141 int rlen = strlen(s); |
143 |
142 |
144 if(t > 255){ |
143 if(rlen > 255){ |
145 printf("pchar2str, length > 255\n"); |
144 rlen = 255; |
146 assert(0); |
145 } |
147 } |
146 |
148 |
147 result.len = rlen; |
149 result.len = t; |
148 memcpy(result.str, s, rlen); |
150 memcpy(result.str, s, t); |
149 |
151 result.str[t] = 0; |
150 return result; |
152 |
151 } |
153 return result; |
152 |
154 } |
|
155 |
153 |
156 string255 fpcrtl_make_string(const char* s) { |
154 string255 fpcrtl_make_string(const char* s) { |
|
155 return fpcrtl_pchar2str(s); |
|
156 } |
|
157 |
|
158 |
|
159 astring fpcrtl_pchar2astr(const char *s) |
|
160 { |
|
161 astring result; |
|
162 int rlen = strlen(s); |
|
163 |
|
164 if(rlen > MAX_ANSISTRING_LENGTH){ |
|
165 rlen = MAX_ANSISTRING_LENGTH; |
|
166 } |
|
167 |
|
168 result.len = rlen; |
|
169 memcpy(result.s + 1, s, rlen); |
|
170 |
|
171 return result; |
|
172 } |
|
173 |
|
174 astring fpcrtl_str2astr(string255 s) |
|
175 { |
|
176 astring result; |
|
177 |
|
178 result.str255 = s; |
|
179 result.len = s.len; |
|
180 |
|
181 return result; |
|
182 } |
|
183 |
|
184 string255 fpcrtl_astr2str(astring s) |
|
185 { |
157 string255 result; |
186 string255 result; |
158 strcpy(result.str, s); |
187 |
159 result.len = strlen(s); |
188 result = s.str255; |
160 return result; |
189 result.len = s.len > 255 ? 255 : s.len; |
|
190 |
|
191 return result; |
|
192 } |
|
193 |
|
194 char __pcharBuf[256]; |
|
195 |
|
196 char* fpcrtl__pchar__vars(string255 * s) |
|
197 { |
|
198 if(s->len < 255) |
|
199 { |
|
200 s->s[s->len] = 0; |
|
201 return &s->s[1]; |
|
202 } else |
|
203 { |
|
204 memcpy(__pcharBuf, s->s[1], 255); |
|
205 __pcharBuf[255] = 0; |
|
206 return &__pcharBuf; |
|
207 } |
|
208 } |
|
209 |
|
210 char* fpcrtl__pcharA__vars(astring * s) |
|
211 { |
|
212 if(s->len == MAX_ANSISTRING_LENGTH) |
|
213 --s->len; |
|
214 |
|
215 s->s[s->len] = 0; |
|
216 return &s->s[1]; |
161 } |
217 } |
162 |
218 |
163 #ifdef EMSCRIPTEN |
219 #ifdef EMSCRIPTEN |
164 GLenum glewInit() |
220 GLenum glewInit() |
165 { |
221 { |