/* ----------------- */
void test_str_end(void)
/* ----------------- */
{
char *str, *ptr;
puts("--------------------");
puts("--- test_str_end ---");
puts("--------------------");
// ptr doit pointer ver '\0'
// donc ptr -1 doit pointer vers le dernier char de la chaine, celui qu'on affiche
// le second affichage est pour le debug
str = "abcdef"; ptr = str_end(str); printf("%s\n", ptr-1); CHAINE_VERBOSE(printf("%s: %p %p\n", str, str, ptr));
str = "a"; ptr = str_end(str); printf("%s\n", ptr-1); CHAINE_VERBOSE(printf("%s: %p %p\n", str, str, ptr));
str = ""; ptr = str_end(str); printf("%s\n", ptr-1); CHAINE_VERBOSE(printf("%s: %p %p\n", str, str, ptr));
}
static void parse_node_class_name(syntree_t st) {
syntree_named_start(st, XCSS_NODE_CLASS_NAME);
if(err())
return;
else {
str_it_t i, e, j;
i = syntree_position(st);
e = str_end(syntree_str(st));
while(1) {
p_skip(i, e, isclass_name_char(*i));
if(i==e)
goto error;
j = i;
p_skip_spaces(j, e);
if(j==e)
goto error;
if(!isclass_name_char(*j))
break;
i = j;
}
if(i!=e) {
syntree_seek(st, i);
syntree_named_end(st);
return;
}
error:
syntree_seek(st, i);
err_set(e_xcss_syntax);
return;
}
}
static void parse_node_namespace(syntree_t st) {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i, e);
syntree_seek(st, i);
parse_node_name(st);
if(err())
return;
i = syntree_position(st);
p_skip_spaces(i,e);
if(i==e ? 1 : *i!='[')
goto error;
i++;
while(i<e) {
p_skip_spaces(i, e);
if(i==e)
goto error;
if(*i==']') {
syntree_seek(st, i+1);
return;
}
syntree_seek(st, i);
xcss_parse(st);
if(err())
return;
i = syntree_position(st);
if(i==e)
goto error;
}
error:
syntree_seek(st, i);
err_set(e_xcss_syntax);
return;
}
static void parse_node_class_parent(syntree_t st) {
str_it_t i, e;
syntree_named_start(st, XCSS_NODE_CLASS_PARENT);
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i, e);
if(i==e ? 1 : *i!='(')
goto error;
i++;
syntree_seek(st, i);
parse_node_class_name(st);
while(!err()) {
i = syntree_position(st);
p_skip_spaces(i, e);
if(i==e)
goto error;
if(*i==')') {
syntree_seek(st, i+1);
syntree_named_end(st);
return;
} else if(*i==',') {
i++;
p_skip_spaces(i, e);
syntree_seek(st,i);
parse_node_class_name(st);
} else
goto error;
}
error:
syntree_seek(st, i);
err_set(e_xcss_syntax);
return;
}
static void parse_node_include(syntree_t st) {
str_it_t i, j, e;
static char include_str[] = "include";
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i, e);
if((e-i)<7)
goto error;
for(j=include_str; *j; j++, *i++)
if(*i!=*j)
goto error;
p_skip_spaces(i, e);
if((e-i)<5)
goto error;
p_skip_spaces(i, e);
if(*i!='(')
goto error;
i++;
p_skip_spaces(i, e);
if(*i!='"')
goto error;
i++;
syntree_seek(st, i);
syntree_named_start(st, XCSS_NODE_INCLUDE_NAME);
if(err())
return;
p_skip(i, e, (isgraph(*i) && *i!=':' && *i!='"') || *i==' ');
syntree_seek(st,i);
syntree_named_end(st);
if(err())
return;
if(i==e)
goto error;
if(*i!='"')
goto error;
i++;
p_skip_spaces(i, e);
if(i==e)
goto error;
if(*i!=')')
goto error;
i++;
if(i==e)
goto error;
p_skip_spaces(i, e);
if(i==e)
goto error;
if(*i!=';')
goto error;
syntree_seek(st, i+1);
return;
error:
syntree_seek(st, i);
err_set(e_xcss_syntax);
return;
}
static void xcss_parse(syntree_t res) {
xcss_node_type_t nd_type;
str_it_t e = str_end(syntree_str(res));
if(nd_type = get_node_type(syntree_position(res), e)) {
syntree_named_start(res, nd_type);
if(err())
return;
switch(nd_type) {
case XCSS_NODE_RULE:
parse_node_rule(res);
break;
case XCSS_NODE_NAMESPACE:
parse_node_namespace(res);
break;
case XCSS_NODE_CLASS:
parse_node_class(res);
break;
case XCSS_NODE_COMMENT:
parse_node_comment(res);
break;
case XCSS_NODE_INCLUDE:
parse_node_include(res);
break;
default: {
assert(0); /* Invalid node type*/
}
}
if(err())
return;
syntree_named_end(res);
} else {
str_it_t i = syntree_position(res);
str_it_t e = str_end(syntree_str(res));
p_skip_spaces(i, e);
syntree_seek(res, i);
if(i!=e) {
err_set(e_xcss_syntax);
return;
}
}
return;
}
main()
{
char skr[100]="tiljo@trooo";
char t[100]="trooo";
char i=0,j=0;
printf("%d\n",str_end(skr,t));
printf("%s \n",skr);
}
void _STLP_CALL
__convert_float_buffer(__iostring const& str, __iowstring &out,
const ctype<wchar_t>& ct, wchar_t dot, bool __check_dot) {
wchar_t __static_buf[128];
wchar_t *__beg = __static_buf;
wchar_t *__end = __static_buf + (sizeof(__static_buf) / sizeof(wchar_t));
string::const_iterator str_ite(str.begin()), str_end(str.end());
wchar_t *__cur = __beg;
//First loop, check the dot char
if (__check_dot) {
while (str_ite != str_end) {
if (*str_ite != '.') {
*__cur = ct.widen(*str_ite);
} else {
*__cur = dot;
break;
}
++__cur;
if (__cur == __end) {
out.append(__beg, __cur);
__cur = __beg;
}
++str_ite;
}
} else {
if (str_ite != str_end) {
*__cur = ct.widen(*str_ite);
}
}
if (str_ite != str_end) {
++__cur;
++str_ite;
if (__cur == __end) {
out.append(__beg, __cur);
__cur = __beg;
}
//Second loop, dot has been found, no check anymore
while (str_ite != str_end) {
*__cur = ct.widen(*str_ite);
++__cur;
if (__cur == __end) {
out.append(__beg, __cur);
__cur = __beg;
}
++str_ite;
}
}
out.append(__beg, __cur);
}
static void parse_node_class(syntree_t st) {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i, e);
syntree_seek(st, i);
parse_node_class_name(st);
if(err())
return;
i = syntree_position(st);
p_skip_spaces(i,e);
if(i==e)
goto error;
if(*i=='(') {
parse_node_class_parent(st);
if(err())
return;
i = syntree_position(st);
p_skip_spaces(i,e);
if(i==e)
goto error;
}
if(*i=='{') {
i++;
while(i<e) {
p_skip_spaces(i, e);
if(i==e)
goto error;
syntree_seek(st, i);
if(*i=='/')
parse_node_comment(st);
else if(*i=='}') {
syntree_seek(st, i+1);
return;
} else {
syntree_named_start(st, XCSS_NODE_RULE);
if(err())
return;
parse_node_rule(st);
if(err())
return;
syntree_named_end(st);
if(err())
return;
}
i = syntree_position(st);
}
}
error:
syntree_seek(st, i);
err_set(e_xcss_syntax);
return;
}
size_t utf_length(str_t s, int enc) {
size_t res = 0;
str_it_t i = str_begin(s);
str_it_t e = str_end(s);
while(i<e) {
int cl = CHAR_LEN(i, enc);
res++;
i += cl;
if(i>e)
err_throw(e_utf_conversion);
}
return res;
}
syntree_t xcss_to_syntree(heap_t h, str_t xcss) {
str_it_t i, e;
syntree_t res = syntree_create(h, xcss);
if(err())
return 0;
e = str_end(xcss);
while(syntree_position(res)!=e) {
xcss_parse(res);
if(err())
return 0;
}
return res;
}
str_t utf_convert(heap_t h, str_t src, int src_enc, int dest_enc) {
str_t res = str_create(h, utf_length(src, src_enc)*4);
str_it_t src_i = str_begin(src),
src_e = str_end(src),
res_i = str_begin(res);
while(src_i<src_e) {
long c = CHAR_TO_LONG(src_i, src_enc);
src_i += CHAR_LEN(src_i, src_enc);
res_i = LONG_TO_UTF(c, res_i, dest_enc);
}
res->length = res_i - str_begin(res);
*res_i = 0;
return res;
}
// Превратить время/дату файла в строку в соответствии с настройками locale или заданными форматами времени и даты
void GuiFormatDateTime (time_t t, char *buf, int bufsize, char *date_format, char *time_format)
{
if (t<0) t=INT_MAX; // Иначе получаем вылет :(
FILETIME ft1, ft2;
UnixTimeToFileTime (t, &ft1);
FileTimeToLocalFileTime (&ft1, &ft2);
SYSTEMTIME datetime;
FileTimeToSystemTime (&ft2, &datetime);
GetDateFormatA(LOCALE_USER_DEFAULT, 0, &datetime, date_format, buf, bufsize);
char *p = str_end(buf);
*p++ = ' ';
GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &datetime, time_format, p, bufsize - (p-buf));
}
static void parse_node_name(syntree_t st) {
syntree_named_start(st, XCSS_NODE_NAME);
if(err())
return;
else {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip(i, e, isalnum(*i) || (*i=='_') || (*i=='-'));
if(i==e) {
err_set(e_xcss_syntax);
} else {
syntree_seek(st, i);
syntree_named_end(st);
}
}
}
static void parse_node_comment(syntree_t st) {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i, e);
if((e-i)>=2 ? i[0]!='/' || i[1]!='*' : 1) {
err_set(e_xcss_syntax);
return;
}
i+=2;
for(; i<e; i++) {
if((e-i)>=2 ? i[0]=='*' && i[1]=='/' : 0) {
syntree_seek(st, i+2);
return;
}
}
err_set(e_xcss_syntax);
}
static void parse_node_rule(syntree_t st) {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
p_skip_spaces(i,e);
syntree_seek(st, i);
parse_node_name(st);
if(err())
return;
i = syntree_position(st);
p_skip_spaces(i,e);
if(i==e ? 1 : (*i)!=':') {
err_set(e_xcss_syntax);
return;
}
i++;
p_skip_spaces(i,e);
syntree_seek(st, i);
parse_node_value(st);
return;
}
static void parse_node_value(syntree_t st) {
str_it_t i, e;
i = syntree_position(st);
e = str_end(syntree_str(st));
syntree_named_start(st, XCSS_NODE_VALUE);
if(err())
return;
while(i<e ? *i!=';' : 0) {
if((e-i)>=2 ? i[0]=='$' && i[1]=='{' : 0) {
syntree_seek(st, i+2);
parse_node_name(st);
i = syntree_position(st);
if(i<e ? *i!='}' : 1) {
err_set(e_xcss_syntax);
return;
}
i++;
syntree_seek(st, i);
} else {
syntree_named_start(st, XCSS_NODE_TEXT);
if(err())
return;
while(i<e && *i!=';') {
i++;
if((e-i)>=2 ? i[0]=='$' && i[1]=='{' : 0)
break;
}
syntree_seek(st, i);
syntree_named_end(st);
}
}
if(i==e) {
err_set(e_xcss_syntax);
} else {
syntree_seek(st, i+1);
syntree_named_end(st);
}
}
// Add CLS-enabled compressors from cls-*.dll
int AddClsCompressors()
{
int registered_methods = 0;
#ifdef FREEARC_WIN // Non-Windows platforms aren't yet supported
// Get program's executable filename
char path[MY_FILENAME_MAX];
GetModuleFileNameA(NULL, path, MY_FILENAME_MAX);
// Replace basename part with "cls-*.dll"
char *basename = strrchr(path,'\\')+1;
strcpy(basename, "cls-*.dll");
// Find all cls-*.dll from program's directory
WIN32_FIND_DATAA FindData;
HANDLE ff = FindFirstFileA(path, &FindData);
for(BOOL found = (ff!=INVALID_HANDLE_VALUE); found; found = FindNextFileA(ff, &FindData))
{
// Put full DLL filename into `path`
strcpy(basename, FindData.cFileName);
// If DLL contains ClsMain() function - register it as dll-based compressor
HMODULE dll = LoadLibraryA(path);
CLS_MAIN *ClsMain = (CLS_MAIN*) GetProcAddress (dll, "ClsMain");
if (ClsMain)
{
str_end(path)[-4] = '\0';
strlwr(basename);
CLS_METHOD *cls = new CLS_METHOD(basename+4, ClsMain);
AddExternalCompressionMethod (parse_CLS, cls);
registered_methods++;
}
}
#endif
return registered_methods;
}
inline std::size_t str_size( const Char* const& s )
{
return str_end( s ) - s;
}
inline Char* str_end( Char* s )
{
return const_cast<Char*>( str_end( s, s ) );
}
int sdp_parse(str *body, GQueue *sessions) {
char *b, *end, *value, *line_end, *next_line;
struct sdp_session *session = NULL;
struct sdp_media *media = NULL;
const char *errstr;
struct sdp_attributes *attrs;
struct sdp_attribute *attr;
str *adj_s;
GQueue *attr_queue;
b = body->s;
end = str_end(body);
while (b && b < end - 1) {
#ifdef TERMINATE_SDP_AT_BLANK_LINE
if (b[0] == '\n' || b[0] == '\r') {
body->len = b - body->s;
break;
}
#endif
errstr = "Missing '=' sign";
if (b[1] != '=')
goto error;
value = &b[2];
line_end = memchr(value, '\n', end - value);
if (!line_end) {
/* assume missing LF at end of body */
line_end = end;
next_line = NULL;
}
else {
next_line = line_end + 1;
if (line_end[-1] == '\r')
line_end--;
}
switch (b[0]) {
case 'v':
errstr = "Error in v= line";
if (line_end != value + 1)
goto error;
if (value[0] != '0')
goto error;
session = g_slice_alloc0(sizeof(*session));
g_queue_init(&session->media_streams);
attrs_init(&session->attributes);
g_queue_push_tail(sessions, session);
media = NULL;
session->s.s = b;
session->rr = session->rs = -1;
break;
case 'o':
errstr = "o= line found within media section";
if (media)
goto error;
errstr = "Error parsing o= line";
if (parse_origin(value, line_end, &session->origin))
goto error;
break;
case 'm':
media = g_slice_alloc0(sizeof(*media));
media->session = session;
attrs_init(&media->attributes);
errstr = "Error parsing m= line";
if (parse_media(value, line_end, media))
goto error;
g_queue_push_tail(&session->media_streams, media);
media->s.s = b;
media->rr = media->rs = -1;
break;
case 'c':
errstr = "Error parsing c= line";
if (parse_connection(value, line_end,
media ? &media->connection : &session->connection))
goto error;
break;
case 'a':
attr = g_slice_alloc0(sizeof(*attr));
attr->full_line.s = b;
attr->full_line.len = next_line ? (next_line - b) : (line_end - b);
attr->line_value.s = value;
attr->line_value.len = line_end - value;
if (parse_attribute(attr)) {
g_slice_free1(sizeof(*attr), attr);
break;
}
attrs = media ? &media->attributes : &session->attributes;
g_queue_push_tail(&attrs->list, attr);
/* g_hash_table_insert(attrs->name_hash, &attr->name, attr); */
if (!g_hash_table_lookup(attrs->id_hash, &attr->attr))
g_hash_table_insert(attrs->id_hash, &attr->attr, attr);
/* if (attr->key.s)
g_hash_table_insert(attrs->name_hash, &attr->key, attr); */
/* attr_queue = g_hash_table_lookup(attrs->name_lists_hash, &attr->name);
if (!attr_queue)
g_hash_table_insert(attrs->name_lists_hash, &attr->name,
(attr_queue = g_queue_new()));
g_queue_push_tail(attr_queue, attr); */
attr_queue = g_hash_table_lookup(attrs->id_lists_hash, &attr->attr);
if (!attr_queue)
g_hash_table_insert(attrs->id_lists_hash, &attr->attr,
(attr_queue = g_queue_new()));
g_queue_push_tail(attr_queue, attr);
break;
case 'b':
/* RR:0 */
if (line_end - value < 4)
break;
if (!memcmp(value, "RR:", 3))
*(media ? &media->rr : &session->rr) =
(line_end - value == 4 && value[3] == '0') ? 0 : 1;
else if (!memcmp(value, "RS:", 3))
*(media ? &media->rs : &session->rs) =
(line_end - value == 4 && value[3] == '0') ? 0 : 1;
break;
case 's':
case 'i':
case 'u':
case 'e':
case 'p':
case 't':
case 'r':
case 'z':
case 'k':
break;
default:
errstr = "Unknown SDP line type found";
goto error;
}
errstr = "SDP doesn't start with a session definition";
if (!session)
goto error;
adj_s = media ? &media->s : &session->s;
adj_s->len = (next_line ? : end) - adj_s->s;
b = next_line;
}
return 0;
error:
ilog(LOG_WARNING, "Error parsing SDP at offset %li: %s", (long) (b - body->s), errstr);
sdp_free(sessions);
return -1;
}
