[Mplayerxp-cvslog] SF.net SVN: mplayerxp:[547] mplayerxp

[<nic...@us...>]

Revision: 547
          http://mplayerxp.svn.sourceforge.net/mplayerxp/?rev=547&view=rev
Author:   nickols_k
Date:     2012-12-12 09:07:39 +0000 (Wed, 12 Dec 2012)
Log Message:
-----------
convert struct ASX_Parser_t into class ASX_Parser + accuracies

Modified Paths:
--------------
    mplayerxp/libplaytree/asxparser.cpp
    mplayerxp/libplaytree/asxparser.h
    mplayerxp/libplaytree/playtreeparser.cpp
    mplayerxp/mplayerxp.cpp
    mplayerxp/mplayerxp.h
    mplayerxp/osdep/aclib.cpp
    mplayerxp/osdep/aclib_template.h
    mplayerxp/osdep/fastmemcpy.h
    mplayerxp/osdep/mp_malloc.cpp
    mplayerxp/osdep/mplib.h
    mplayerxp/postproc/libmenu/menu.cpp
    mplayerxp/postproc/libmenu/menu_cmdlist.cpp
    mplayerxp/postproc/libmenu/menu_param.cpp

Modified: mplayerxp/libplaytree/asxparser.cpp
===================================================================
--- mplayerxp/libplaytree/asxparser.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/libplaytree/asxparser.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -17,7 +17,7 @@
 #include "mp_msg.h"
 
 ////// List utils
-
+namespace mpxp {
 static void __FASTCALL__ asx_list_add(any_t* list_ptr,any_t* entry){
   any_t** list = *(any_t***)list_ptr;
   int c = 0;
@@ -77,90 +77,78 @@
 /////// Attribs utils
 
 char* __FASTCALL__ asx_get_attrib(const char* attrib,char** attribs) {
-  char** ptr;
+    char** ptr;
 
-  if(attrib == NULL || attribs == NULL) return NULL;
-  for(ptr = attribs; ptr[0] != NULL; ptr += 2){
-    if(strcasecmp(ptr[0],attrib) == 0)
-      return mp_strdup(ptr[1]);
-  }
-  return NULL;
+    if(attrib == NULL || attribs == NULL) return NULL;
+    for(ptr = attribs; ptr[0] != NULL; ptr += 2){
+	if(strcasecmp(ptr[0],attrib) == 0) return mp_strdup(ptr[1]);
+    }
+    return NULL;
 }
 
 int __FASTCALL__ asx_attrib_to_enum(const char* val,const char** valid_vals) {
-  const char** ptr;
-  int r = 0;
+    const char** ptr;
+    int r = 0;
 
-  if(valid_vals == NULL || val == NULL) return -2;
-  for(ptr = valid_vals ; ptr[0] != NULL ; ptr++) {
-    if(strcasecmp(val,ptr[0]) == 0) return r;
-    r++;
-  }
-
-  return -1;
+    if(valid_vals == NULL || val == NULL) return -2;
+    for(ptr = valid_vals ; ptr[0] != NULL ; ptr++) {
+	if(strcasecmp(val,ptr[0]) == 0) return r;
+	r++;
+    }
+    return -1;
 }
 
-static void __FASTCALL__ asx_warning_attrib_invalid(ASX_Parser_t* parser, char* elem, char* attrib,
-			   const char** valid_vals,char* val) {
-  char *str,*vals;
-  const char **ptr;
-  int len;
+void ASX_Parser::warning_attrib_invalid(char* elem, char* attrib,
+					const char** valid_vals,char* val)
+{
+    char *str,*vals;
+    const char **ptr;
+    int len;
 
-  if(valid_vals == NULL || valid_vals[0] == NULL) return;
+    if(valid_vals == NULL || valid_vals[0] == NULL) return;
 
-  len = strlen(valid_vals[0]) + 1;
-  for(ptr = valid_vals+1 ; ptr[0] != NULL; ptr++) {
-    len += strlen(ptr[0]);
-    len += ((ptr[1] == NULL) ? 4 : 2);
-  }
-  str = vals = new char[len];
-  vals += sprintf(vals,"%s",valid_vals[0]);
-  for(ptr = valid_vals + 1 ; ptr[0] != NULL ; ptr++) {
-    if(ptr[1] == NULL)
-      vals += sprintf(vals," or %s",ptr[0]);
-    else
-      vals += sprintf(vals,", %s",ptr[0]);
-  }
-  MSG_ERR("at line %d : attribute %s of element %s is invalid (%s). Valid values are %s",
-	      parser->line,attrib,elem,val,str);
-  delete str;
+    len = strlen(valid_vals[0]) + 1;
+    for(ptr = valid_vals+1 ; ptr[0] != NULL; ptr++) {
+	len += strlen(ptr[0]);
+	len += ((ptr[1] == NULL) ? 4 : 2);
+    }
+    str = vals = new char[len];
+    vals += sprintf(vals,"%s",valid_vals[0]);
+    for(ptr = valid_vals + 1 ; ptr[0] != NULL ; ptr++) {
+	if(ptr[1] == NULL)	vals += sprintf(vals," or %s",ptr[0]);
+	else			vals += sprintf(vals,", %s",ptr[0]);
+    }
+    MSG_ERR("at line %d : attribute %s of element %s is invalid (%s). Valid values are %s",
+	    line,attrib,elem,val,str);
+    delete str;
 }
 
-static int __FASTCALL__ asx_get_yes_no_attrib(ASX_Parser_t* parser, char* element, char* attrib,char** attribs,int def) {
-  char* val = asx_get_attrib(attrib,attribs);
-  const char* valids[] = { "NO", "YES", NULL };
-  int r;
+int ASX_Parser::get_yes_no_attrib(char* element, char* attrib,char** cattribs,int def) {
+    char* val = asx_get_attrib(attrib,cattribs);
+    const char* valids[] = { "NO", "YES", NULL };
+    int r;
 
-  if(val == NULL) return def;
-  r = asx_attrib_to_enum(val,valids);
+    if(val == NULL) return def;
+    r = asx_attrib_to_enum(val,valids);
 
-  if(r < 0) {
-    asx_warning_attrib_invalid(parser,element,attrib,valids,val);
-    r = def;
-  }
-
-  delete val;
-  return r;
+    if(r < 0) {
+	warning_attrib_invalid(element,attrib,valids,val);
+	r = def;
+    }
+    delete val;
+    return r;
 }
 
-#define asx_warning_attrib_required(p,e,a) MSG_WARN("At line %d : element %s don't have the required attribute %s",p->line,e,a)
-#define asx_warning_body_parse_error(p,e) MSG_WARN("At line %d : error while parsing %s body",p->line,e)
+void ASX_Parser::warning_attrib_required(const char *e, const char *a) { MSG_WARN("At line %d : element %s don't have the required attribute %s",line,e,a); }
+void ASX_Parser::warning_body_parse_error(const char *e) { MSG_WARN("At line %d : error while parsing %s body",line,e); }
 
-ASX_Parser_t* asx_parser_new(void) {
-    ASX_Parser_t* parser = new(zeromem) ASX_Parser_t;
-    return parser;
-}
+ASX_Parser::ASX_Parser() {}
+ASX_Parser::~ASX_Parser() { if(ret_stack) delete ret_stack; }
 
-void __FASTCALL__ asx_parser_free(ASX_Parser_t* parser) {
-    if(!parser) return;
-    if(parser->ret_stack) delete parser->ret_stack;
-    delete parser;
-}
-
-int __FASTCALL__ asx_parse_attribs(ASX_Parser_t* parser,char* buffer,char*** _attribs) {
+int ASX_Parser::parse_attribs(char* buffer,char*** _attribs) {
     char *ptr1, *ptr2, *ptr3;
     int n_attrib = 0;
-    char **attribs = NULL;
+    char **cattribs = NULL;
     char *attrib, *val;
 
     ptr1 = buffer;
@@ -172,7 +160,7 @@
 	if(ptr3 == NULL) break;
 	for(ptr2 = ptr3-1; isspace(*ptr2); ptr2--) {
 	    if (ptr2 <= ptr1) {
-		MSG_ERR("At line %d : this should never append, back to attribute begin while skipping end space",parser->line);
+		MSG_ERR("At line %d : this should never append, back to attribute begin while skipping end space",line);
 		goto pa_end;
 	    }
 	}
@@ -182,14 +170,14 @@
 
 	ptr1 = strchr(ptr3,'"');
 	if(ptr1 == NULL || ptr1[1] == '\0') {
-	    MSG_WARN("At line %d : can't find attribute %s value",parser->line,attrib);
+	    MSG_WARN("At line %d : can't find attribute %s value",line,attrib);
 	    delete attrib;
 	    break;
 	}
 	ptr1++;
 	ptr2 = strchr(ptr1,'"');
 	if (ptr2 == NULL) {
-	    MSG_WARN("At line %d : value of attribute %s isn't finished",parser->line,attrib);
+	    MSG_WARN("At line %d : value of attribute %s isn't finished",line,attrib);
 	    delete attrib;
 	    break;
 	}
@@ -198,521 +186,483 @@
 	val[ptr2-ptr1] = '\0';
 	n_attrib++;
 
-	attribs = (char**)mp_realloc(attribs,(2*n_attrib+1)*sizeof(char*));
-	attribs[n_attrib*2-2] = attrib;
-	attribs[n_attrib*2-1] = val;
+	cattribs = (char**)mp_realloc(cattribs,(2*n_attrib+1)*sizeof(char*));
+	cattribs[n_attrib*2-2] = attrib;
+	cattribs[n_attrib*2-1] = val;
 
 	ptr1 = ptr2+1;
     }
 pa_end:
     if(n_attrib > 0)
-	attribs[n_attrib*2-0] = NULL;
-    *_attribs = attribs;
+	cattribs[n_attrib*2-0] = NULL;
+    *_attribs = cattribs;
     return n_attrib;
 }
 
 /*
  * Return -1 on error, 0 when nothing is found, 1 on sucess
  */
-int __FASTCALL__ asx_get_element(ASX_Parser_t* parser,const char** _buffer,
-		char** _element,char** _body,char*** _attribs) {
-  const char *ptr1,*ptr2, *ptr3, *ptr4;
-  char *attribs = NULL;
-  char *element = NULL, *body = NULL;
-  const char *ret = NULL;
-  const char *buffer;
-  int n_attrib = 0;
-  int body_line = 0,attrib_line,ret_line,in = 0;
+int ASX_Parser::get_element(const char** _buffer, char** _element,
+			    char** _body,char*** _attribs) {
+    const char *ptr1,*ptr2, *ptr3, *ptr4;
+    char *cattribs = NULL;
+    char *element = NULL, *body = NULL;
+    const char *ret = NULL;
+    const char *buffer;
+    int n_attrib = 0;
+    int body_line = 0,attrib_line,ret_line,in = 0;
 
-  if(_buffer == NULL || _element == NULL || _body == NULL || _attribs == NULL) {
-    MSG_ERR("At line %d : asx_get_element called with invalid value",parser->line);
-    return -1;
-  }
+    if(_buffer == NULL || _element == NULL || _body == NULL || _attribs == NULL) {
+	MSG_ERR("At line %d : asx_get_element called with invalid value",line);
+	return -1;
+    }
 
-  *_body = *_element = NULL;
-  *_attribs =  NULL;
-  buffer = *_buffer;
+    *_body = *_element = NULL;
+    *_attribs =  NULL;
+    buffer = *_buffer;
 
-  if(buffer == NULL) return 0;
+    if(buffer == NULL) return 0;
 
-  if(parser->ret_stack && /*parser->last_body && */buffer != parser->last_body) {
-    ASX_LineSave_t* ls = parser->ret_stack;
-    int i;
-    for(i = 0 ; i < parser->ret_stack_size ; i++) {
-      if(buffer == ls[i].buffer) {
-	parser->line = ls[i].line;
-	break;
-      }
-
+    if(ret_stack && /*last_body && */buffer != last_body) {
+	ASX_LineSave_t* ls = ret_stack;
+	int i;
+	for(i = 0 ; i < ret_stack_size ; i++) {
+	    if(buffer == ls[i].buffer) {
+		line = ls[i].line;
+		break;
+	    }
+	}
+	if( i < ret_stack_size) {
+	    i++;
+	    if( i < ret_stack_size) memmove(ret_stack,ret_stack+i, (ret_stack_size - i)*sizeof(ASX_LineSave_t));
+	    ret_stack_size -= i;
+	    if(ret_stack_size > 0) ret_stack = (ASX_LineSave_t*)mp_realloc(ret_stack,ret_stack_size*sizeof(ASX_LineSave_t));
+	    else {
+		delete ret_stack;
+		ret_stack = NULL;
+	    }
+	}
     }
-    if( i < parser->ret_stack_size) {
-      i++;
-      if( i < parser->ret_stack_size)
-	memmove(parser->ret_stack,parser->ret_stack+i, (parser->ret_stack_size - i)*sizeof(ASX_LineSave_t));
-      parser->ret_stack_size -= i;
-      if(parser->ret_stack_size > 0)
-	parser->ret_stack = (ASX_LineSave_t*)mp_realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));
-      else {
-	delete parser->ret_stack;
-	parser->ret_stack = NULL;
-      }
-    }
-  }
+    ptr1 = buffer;
+    while(1) {
+	for( ; ptr1[0] != '<' ; ptr1++) {
+	    if(ptr1[0] == '\0') {
+		ptr1 = NULL;
+		break;
+	    }
+	    if(ptr1[0] == '\n') line++;
+	}
+	//ptr1 = strchr(ptr1,'<');
+	if(!ptr1 || ptr1[1] == '\0') return 0; // Nothing found
 
-  ptr1 = buffer;
-  while(1) {
-    for( ; ptr1[0] != '<' ; ptr1++) {
-      if(ptr1[0] == '\0') {
-	ptr1 = NULL;
-	break;
-      }
-      if(ptr1[0] == '\n') parser->line++;
+	if(strncmp(ptr1,"<!--",4) == 0) { // Comments
+	    for( ; strncmp(ptr1,"-->",3) != 0 ; ptr1++) {
+		if(ptr1[0] == '\0') {
+		    ptr1 = NULL;
+		    break;
+		}
+		if(ptr1[0] == '\n') line++;
+	    }
+	    //ptr1 = strstr(ptr1,"-->");
+	    if(!ptr1) {
+		MSG_ERR("At line %d : unfinished comment",line);
+		return -1;
+	    }
+	} else break;
     }
-    //ptr1 = strchr(ptr1,'<');
-    if(!ptr1 || ptr1[1] == '\0') return 0; // Nothing found
 
-    if(strncmp(ptr1,"<!--",4) == 0) { // Comments
-      for( ; strncmp(ptr1,"-->",3) != 0 ; ptr1++) {
+    // Is this space skip very useful ??
+    for(ptr1++; isspace(ptr1[0]); ptr1++) { // Skip space
 	if(ptr1[0] == '\0') {
-	  ptr1 = NULL;
-	  break;
+	    MSG_ERR("At line %d : EOB reached while parsing element start",line);
+	    return -1;
 	}
-	if(ptr1[0] == '\n') parser->line++;
-      }
-      //ptr1 = strstr(ptr1,"-->");
-      if(!ptr1) {
-	MSG_ERR("At line %d : unfinished comment",parser->line);
-	return -1;
-      }
-    } else {
-      break;
+	if(ptr1[0] == '\n') line++;
     }
-  }
 
-  // Is this space skip very useful ??
-  for(ptr1++; isspace(ptr1[0]); ptr1++) { // Skip space
-    if(ptr1[0] == '\0') {
-      MSG_ERR("At line %d : EOB reached while parsing element start",parser->line);
-      return -1;
+    for(ptr2 = ptr1; isalpha(*ptr2); ptr2++) { // Go to end of name
+	if(*ptr2 == '\0'){
+	    MSG_ERR("At line %d : EOB reached while parsing element start",line);
+	    return -1;
+	}
+	if(ptr2[0] == '\n') line++;
     }
-    if(ptr1[0] == '\n') parser->line++;
-  }
 
-  for(ptr2 = ptr1; isalpha(*ptr2); ptr2++) { // Go to end of name
-    if(*ptr2 == '\0'){
-      MSG_ERR("At line %d : EOB reached while parsing element start",parser->line);
-      return -1;
-    }
-    if(ptr2[0] == '\n') parser->line++;
-  }
+    element = new char[ptr2-ptr1+1];
+    strncpy(element,ptr1,ptr2-ptr1);
+    element[ptr2-ptr1] = '\0';
 
-  element = new char[ptr2-ptr1+1];
-  strncpy(element,ptr1,ptr2-ptr1);
-  element[ptr2-ptr1] = '\0';
-
-  for( ; isspace(*ptr2); ptr2++) { // Skip space
-    if(ptr2[0] == '\0') {
-      MSG_ERR("At line %d : EOB reached while parsing element start",parser->line);
-      delete element;
-      return -1;
+    for( ; isspace(*ptr2); ptr2++) { // Skip space
+	if(ptr2[0] == '\0') {
+	    MSG_ERR("At line %d : EOB reached while parsing element start",line);
+	    delete element;
+	    return -1;
+	}
+	if(ptr2[0] == '\n') line++;
     }
-    if(ptr2[0] == '\n') parser->line++;
-  }
-  attrib_line = parser->line;
+    attrib_line = line;
 
-  for(ptr3 = ptr2; ptr3[0] != '\0'; ptr3++) { // Go to element end
-    if(ptr3[0] == '>' || strncmp(ptr3,"/>",2) == 0)
-      break;
-    if(ptr3[0] == '\n') parser->line++;
-  }
-  if(ptr3[0] == '\0' || ptr3[1] == '\0') { // End of file
-    MSG_ERR("At line %d : EOB reached while parsing element start",parser->line);
-    delete element;
-    return -1;
-  }
-
-  // Save attribs string
-  if(ptr3-ptr2 > 0) {
-    attribs = new char[ptr3-ptr2+1];
-    strncpy(attribs,ptr2,ptr3-ptr2);
-    attribs[ptr3-ptr2] = '\0';
-  }
-  //bs_line = parser->line;
-  if(ptr3[0] != '/') { // Not Self closed element
-    ptr3++;
-    for( ; isspace(*ptr3); ptr3++) { // Skip space on body begin
-      if(*ptr3 == '\0') {
-	MSG_ERR("At line %d : EOB reached while parsing %s element body",parser->line,element);
+    for(ptr3 = ptr2; ptr3[0] != '\0'; ptr3++) { // Go to element end
+	if(ptr3[0] == '>' || strncmp(ptr3,"/>",2) == 0) break;
+	if(ptr3[0] == '\n') line++;
+    }
+    if(ptr3[0] == '\0' || ptr3[1] == '\0') { // End of file
+	MSG_ERR("At line %d : EOB reached while parsing element start",line);
 	delete element;
-	if(attribs) delete attribs;
 	return -1;
-      }
-      if(ptr3[0] == '\n') parser->line++;
     }
-    ptr4 = ptr3;
-    body_line = parser->line;
-    while(1) { // Find closing element
-      for( ; ptr4[0] != '<' ; ptr4++) {
-	if(ptr4[0] == '\0') {
-	  ptr4 = NULL;
-	  break;
+
+    // Save attribs string
+    if(ptr3-ptr2 > 0) {
+	cattribs = new char[ptr3-ptr2+1];
+	strncpy(cattribs,ptr2,ptr3-ptr2);
+	cattribs[ptr3-ptr2] = '\0';
+    }
+    //bs_line = line;
+    if(ptr3[0] != '/') { // Not Self closed element
+	ptr3++;
+	for( ; isspace(*ptr3); ptr3++) { // Skip space on body begin
+	    if(*ptr3 == '\0') {
+		MSG_ERR("At line %d : EOB reached while parsing %s element body",line,element);
+		delete element;
+		if(cattribs) delete cattribs;
+		return -1;
+	    }
+	    if(ptr3[0] == '\n') line++;
 	}
-	if(ptr4[0] == '\n') parser->line++;
-      }
-      if(strncmp(ptr4,"<!--",4) == 0) { // Comments
-	for( ; strncmp(ptr4,"-->",3) != 0 ; ptr4++) {
-	if(ptr4[0] == '\0') {
-	  ptr4 = NULL;
-	  break;
+	ptr4 = ptr3;
+	body_line = line;
+	while(1) { // Find closing element
+	    for( ; ptr4[0] != '<' ; ptr4++) {
+		if(ptr4[0] == '\0') {
+		    ptr4 = NULL;
+		    break;
+		}
+		if(ptr4[0] == '\n') line++;
+	    }
+	    if(strncmp(ptr4,"<!--",4) == 0) { // Comments
+		for( ; strncmp(ptr4,"-->",3) != 0 ; ptr4++) {
+		    if(ptr4[0] == '\0') {
+			ptr4 = NULL;
+			break;
+		    }
+		    if(ptr1[0] == '\n') line++;
+		}
+		continue;
+	    }
+	    if(ptr4 == NULL || ptr4[1] == '\0') {
+		MSG_ERR("At line %d : EOB reached while parsing %s element body",line,element);
+		delete element;
+		if(cattribs) delete cattribs;
+		return -1;
+	    }
+	    if(ptr4[1] != '/' && strncasecmp(element,ptr4+1,strlen(element)) == 0) {
+		in++;
+		ptr4+=2;
+		continue;
+	    } else if(strncasecmp(element,ptr4+2,strlen(element)) == 0) { // Extract body
+		if(in > 0) {
+		    in--;
+		    ptr4 += 2+strlen(element);
+		    continue;
+		}
+		ret = ptr4+strlen(element)+3;
+		if(ptr4 != ptr3) {
+		    ptr4--;
+		    for( ; ptr4 != ptr3 && isspace(*ptr4); ptr4--) ;// Skip space on body end
+		    //	    if(ptr4[0] == '\0') line--;
+		    //}
+		    ptr4++;
+		    body = new char[ptr4-ptr3+1];
+		    strncpy(body,ptr3,ptr4-ptr3);
+		    body[ptr4-ptr3] = '\0';
+	    }
+	    break;
+	    } else {
+		ptr4 += 2;
+	    }
 	}
-	if(ptr1[0] == '\n') parser->line++;
-	}
-	continue;
-      }
-      if(ptr4 == NULL || ptr4[1] == '\0') {
-	MSG_ERR("At line %d : EOB reached while parsing %s element body",parser->line,element);
-	delete element;
-	if(attribs) delete attribs;
-	return -1;
-      }
-      if(ptr4[1] != '/' && strncasecmp(element,ptr4+1,strlen(element)) == 0) {
-	in++;
-	ptr4+=2;
-	continue;
-      } else if(strncasecmp(element,ptr4+2,strlen(element)) == 0) { // Extract body
-	if(in > 0) {
-	  in--;
-	  ptr4 += 2+strlen(element);
-	  continue;
-	}
-	ret = ptr4+strlen(element)+3;
-	if(ptr4 != ptr3) {
-	  ptr4--;
-	  for( ; ptr4 != ptr3 && isspace(*ptr4); ptr4--) ;// Skip space on body end
-	  //	    if(ptr4[0] == '\0') parser->line--;
-	  //}
-	  ptr4++;
-	  body = new char[ptr4-ptr3+1];
-	  strncpy(body,ptr3,ptr4-ptr3);
-	  body[ptr4-ptr3] = '\0';
-	}
-	break;
-      } else {
-	ptr4 += 2;
-      }
+    } else {
+	ret = ptr3 + 2; // 2 is for />
     }
-  } else {
-    ret = ptr3 + 2; // 2 is for />
-  }
 
-  for( ; ret[0] != '\0' && isspace(ret[0]); ret++) { // Skip space
-    if(ret[0] == '\n') parser->line++;
-  }
+    for( ; ret[0] != '\0' && isspace(ret[0]); ret++) { // Skip space
+	if(ret[0] == '\n') line++;
+    }
 
-  ret_line = parser->line;
+    ret_line = line;
 
-  if(attribs) {
-    parser->line = attrib_line;
-    n_attrib = asx_parse_attribs(parser,attribs,_attribs);
-    delete attribs;
-    if(n_attrib < 0) {
-      MSG_WARN("At line %d : error while parsing element %s attributes",parser->line,element);
-      delete element;
-      delete body;
-      return -1;
-    }
-  } else
+    if(cattribs) {
+	line = attrib_line;
+	n_attrib = parse_attribs(cattribs,_attribs);
+	delete cattribs;
+	if(n_attrib < 0) {
+	    MSG_WARN("At line %d : error while parsing element %s attributes",line,element);
+	    delete element;
+	    delete body;
+	    return -1;
+	}
+    } else
     *_attribs = NULL;
 
-  *_element = element;
-  *_body = body;
+    *_element = element;
+    *_body = body;
 
-  parser->last_body = body;
-  parser->ret_stack_size++;
-  parser->ret_stack = (ASX_LineSave_t*)mp_realloc(parser->ret_stack,parser->ret_stack_size*sizeof(ASX_LineSave_t));
-  if(parser->ret_stack_size > 1)
-    memmove(parser->ret_stack+1,parser->ret_stack,(parser->ret_stack_size-1)*sizeof(ASX_LineSave_t));
-  parser->ret_stack[0].buffer = const_cast<char*>(ret);
-  parser->ret_stack[0].line = ret_line;
-  parser->line = body ? body_line : ret_line;
+    last_body = body;
+    ret_stack_size++;
+    ret_stack = (ASX_LineSave_t*)mp_realloc(ret_stack,ret_stack_size*sizeof(ASX_LineSave_t));
+    if(ret_stack_size > 1) memmove(ret_stack+1,ret_stack,(ret_stack_size-1)*sizeof(ASX_LineSave_t));
+    ret_stack[0].buffer = const_cast<char*>(ret);
+    ret_stack[0].line = ret_line;
+    line = body ? body_line : ret_line;
 
-  *_buffer = ret;
-  return 1;
-
+    *_buffer = ret;
+    return 1;
 }
 
-static void __FASTCALL__ asx_parse_param(ASX_Parser_t* parser, char** attribs, play_tree_t* pt) {
-  const char *name,*val;
+void ASX_Parser::param(char** cattribs, play_tree_t* pt) {
+    const char *name,*val;
 
-  name = asx_get_attrib("NAME",attribs);
-  if(!name) {
-    asx_warning_attrib_required(parser,"PARAM" ,"NAME" );
-    return;
-  }
-  val = asx_get_attrib("VALUE",attribs);
-  if(m_config_get_option(mpxp_context().mconfig,name) == NULL) {
-    MSG_WARN("Found unknow param in asx: %s",name);
-    if(val)
-      MSG_WARN("=%s\n",val);
-    else
-      MSG_WARN("\n");
-    return;
-  }
-  play_tree_set_param(pt,name,val);
+    name = asx_get_attrib("NAME",cattribs);
+    if(!name) {
+	warning_attrib_required("PARAM" ,"NAME" );
+	return;
+    }
+    val = asx_get_attrib("VALUE",cattribs);
+    if(m_config_get_option(mpxp_context().mconfig,name) == NULL) {
+	MSG_WARN("Found unknow param in asx: %s",name);
+	if(val)	MSG_WARN("=%s\n",val);
+	else	MSG_WARN("\n");
+	return;
+    }
+    play_tree_set_param(pt,name,val);
 }
 
-static void __FASTCALL__ asx_parse_ref(ASX_Parser_t* parser, char** attribs, play_tree_t* pt) {
-  char *href;
+void ASX_Parser::ref(char** cattribs, play_tree_t* pt) {
+    char *href;
 
-  href = asx_get_attrib("HREF",attribs);
-  if(href == NULL) {
-    asx_warning_attrib_required(parser,"REF" ,"HREF" );
-    return;
-  }
-  // replace http my mmshttp to avoid infinite loops
-  if (strncmp(href, "http://", 7) == 0) {
-    char *newref = new char [3 + strlen(href) + 1];
-    strcpy(newref, "mms");
-    strcpy(newref + 3, href);
+    href = asx_get_attrib("HREF",cattribs);
+    if(href == NULL) {
+	warning_attrib_required("REF" ,"HREF" );
+	return;
+    }
+    // replace http my mmshttp to avoid infinite loops
+    if (strncmp(href, "http://", 7) == 0) {
+	char *newref = new char [3 + strlen(href) + 1];
+	strcpy(newref, "mms");
+	strcpy(newref + 3, href);
+	delete href;
+	href = newref;
+    }
+    play_tree_add_file(pt,href);
+    MSG_V("Adding file %s to element entry\n",href);
     delete href;
-    href = newref;
-  }
-
-  play_tree_add_file(pt,href);
-
-  MSG_V("Adding file %s to element entry\n",href);
-
-  delete href;
-
 }
 
-static play_tree_t* __FASTCALL__ asx_parse_entryref(libinput_t* libinput,ASX_Parser_t* parser,char* buffer,char** _attribs) {
-  play_tree_t* pt;
-  char *href;
-  Stream* stream;
-  play_tree_parser_t* ptp;
-  int f;
-  UNUSED(buffer);
+play_tree_t* ASX_Parser::entryref(libinput_t* libinput,char* buffer,char** _attribs) {
+    play_tree_t* pt;
+    char *href;
+    Stream* stream;
+    play_tree_parser_t* ptp;
+    int f;
+    UNUSED(buffer);
 
-  if(parser->deep > 0)
-    return NULL;
+    if(deep > 0) return NULL;
 
-  href = asx_get_attrib("HREF",_attribs);
-  if(href == NULL) {
-    asx_warning_attrib_required(parser,"ENTRYREF" ,"HREF" );
-    return NULL;
-  }
-  stream=new(zeromem) Stream;
-  if(stream->open(libinput,href,&f)!=MPXP_Ok) {
-    MSG_WARN("Can't open playlist %s\n",href);
+    href = asx_get_attrib("HREF",_attribs);
+    if(href == NULL) {
+	warning_attrib_required("ENTRYREF" ,"HREF" );
+	return NULL;
+    }
+    stream=new(zeromem) Stream;
+    if(stream->open(libinput,href,&f)!=MPXP_Ok) {
+	MSG_WARN("Can't open playlist %s\n",href);
+	delete stream;
+	return NULL;
+    }
+    if(!(stream->type() & Stream::Type_Text)) {
+	MSG_WARN("URL %s dont point to a playlist\n",href);
+	delete stream;
+	return NULL;
+    }
+    MSG_V("Adding playlist %s to element entryref\n",href);
+    ptp = play_tree_parser_new(stream,deep+1);
+    pt = play_tree_parser_get_play_tree(libinput,ptp);
+    play_tree_parser_free(ptp);
     delete stream;
-    return NULL;
-  }
-  if(!(stream->type() & Stream::Type_Text)) {
-    MSG_WARN("URL %s dont point to a playlist\n",href);
-    delete stream;
-    return NULL;
-  }
+//MSG_INFO("Need to implement entryref\n");
+    return pt;
+}
 
-  MSG_V("Adding playlist %s to element entryref\n",href);
+play_tree_t* ASX_Parser::entry(const char* buffer,char** _attribs) {
+    char *celement,*body,**cattribs;
+    int r,nref=0;
+    play_tree_t *pt_ref;
+    UNUSED(_attribs);
 
-  ptp = play_tree_parser_new(stream,parser->deep+1);
+    pt_ref = play_tree_new();
 
-  pt = play_tree_parser_get_play_tree(libinput,ptp);
-
-  play_tree_parser_free(ptp);
-  delete stream;
-
-  //MSG_INFO("Need to implement entryref\n");
-
-  return pt;
+    while(buffer && buffer[0] != '\0') {
+	r = get_element(&buffer,&celement,&body,&cattribs);
+	if(r < 0) {
+	    warning_body_parse_error("ENTRY");
+	    return NULL;
+	} else if (r == 0) break; // No more element
+	if(strcasecmp(celement,"REF") == 0) {
+	    ref(cattribs,pt_ref);
+	    MSG_DBG2("Adding element %s to entry\n",celement);
+	    nref++;
+	} else MSG_DBG2("Ignoring element %s\n",celement);
+	if(body) delete body;
+	asx_free_attribs(cattribs);
+    }
+    if(nref <= 0) {
+	play_tree_free(pt_ref,1);
+	return NULL;
+    }
+    return pt_ref;
 }
 
-static play_tree_t* __FASTCALL__ asx_parse_entry(ASX_Parser_t* parser,const char* buffer,char** _attribs) {
-  char *element,*body,**attribs;
-  int r,nref=0;
-  play_tree_t *ref;
-  UNUSED(_attribs);
+play_tree_t* ASX_Parser::repeat(libinput_t*libinput,const char* buffer,char** _attribs) {
+    char *element,*body,**cattribs;
+    play_tree_t *pt_repeat, *list=NULL, *pt_entry;
+    char* count;
+    int r;
 
-  ref = play_tree_new();
+    pt_repeat = play_tree_new();
 
-  while(buffer && buffer[0] != '\0') {
-    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
-    if(r < 0) {
-      asx_warning_body_parse_error(parser,"ENTRY");
-      return NULL;
-    } else if (r == 0) { // No more element
-      break;
+    count = asx_get_attrib("COUNT",_attribs);
+    if(count == NULL) {
+	MSG_DBG2("Setting element repeat loop to infinit\n");
+	pt_repeat->loop = -1; // Infinit
+    } else {
+	pt_repeat->loop = atoi(count);
+	delete count;
+	if(pt_repeat->loop == 0) pt_repeat->loop = 1;
+	MSG_DBG2("Setting element repeat loop to %d\n",pt_repeat->loop);
     }
-    if(strcasecmp(element,"REF") == 0) {
-      asx_parse_ref(parser,attribs,ref);
-      MSG_DBG2("Adding element %s to entry\n",element);
-      nref++;
-    } else
-      MSG_DBG2("Ignoring element %s\n",element);
-    if(body) delete body;
-    asx_free_attribs(attribs);
-  }
 
-  if(nref <= 0) {
-    play_tree_free(ref,1);
-    return NULL;
-  }
-  return ref;
+    while(buffer && buffer[0] != '\0') {
+	r = get_element(&buffer,&element,&body,&cattribs);
+	if(r < 0) {
+	    warning_body_parse_error("REPEAT");
+	    return NULL;
+	} else if (r == 0) break; // No more element
+	if(strcasecmp(element,"ENTRY") == 0) {
+	    pt_entry = entry(body,cattribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to repeat\n",element);
+	    }
+	} else if(strcasecmp(element,"ENTRYREF") == 0) {
+	    pt_entry = entryref(libinput,body,cattribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to repeat\n",element);
+	    }
+	} else if(strcasecmp(element,"REPEAT") == 0) {
+	    pt_entry = repeat(libinput,body,cattribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to repeat\n",element);
+	    }
+	} else if(strcasecmp(element,"PARAM") == 0) {
+	    param(cattribs,pt_repeat);
+	} else MSG_DBG2("Ignoring element %s\n",element);
+	if(body) delete body;
+	asx_free_attribs(cattribs);
+    }
 
+    if(!list) {
+	play_tree_free(pt_repeat,1);
+	return NULL;
+    }
+    play_tree_set_child(pt_repeat,list);
+    return pt_repeat;
 }
 
-static play_tree_t* __FASTCALL__ asx_parse_repeat(libinput_t*libinput,ASX_Parser_t* parser,const char* buffer,char** _attribs) {
-  char *element,*body,**attribs;
-  play_tree_t *repeat, *list=NULL, *entry;
-  char* count;
-  int r;
+play_tree_t* ASX_Parser::build_tree(libinput_t*libinput,const char* buffer,int deep) {
+    char *element,*asx_body,**asx_attribs,*body, **attribs;
+    int r;
+    play_tree_t *asx,*pt_entry,*list = NULL;
+    ASX_Parser& parser = *new(zeromem) ASX_Parser;
 
-  repeat = play_tree_new();
+    parser.line = 1;
+    parser.deep = deep;
 
-  count = asx_get_attrib("COUNT",_attribs);
-  if(count == NULL) {
-    MSG_DBG2("Setting element repeat loop to infinit\n");
-    repeat->loop = -1; // Infinit
-  } else {
-    repeat->loop = atoi(count);
-    delete count;
-    if(repeat->loop == 0) repeat->loop = 1;
-    MSG_DBG2("Setting element repeat loop to %d\n",repeat->loop);
-  }
-
-  while(buffer && buffer[0] != '\0') {
-    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
+    r = parser.get_element(&buffer,&element,&asx_body,&asx_attribs);
     if(r < 0) {
-      asx_warning_body_parse_error(parser,"REPEAT");
-      return NULL;
-    } else if (r == 0) { // No more element
-      break;
+	MSG_ERR("At line %d : Syntax error ???",parser.line);
+	delete &parser;
+	return NULL;
+    } else if(r == 0) { // No contents
+	MSG_ERR("empty asx element");
+	delete &parser;
+	return NULL;
     }
-    if(strcasecmp(element,"ENTRY") == 0) {
-       entry = asx_parse_entry(parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to repeat\n",element);
-       }
-    } else if(strcasecmp(element,"ENTRYREF") == 0) {
-       entry = asx_parse_entryref(libinput,parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to repeat\n",element);
-       }
-     } else if(strcasecmp(element,"REPEAT") == 0) {
-       entry = asx_parse_repeat(libinput,parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to repeat\n",element);
-       }
-     } else if(strcasecmp(element,"PARAM") == 0) {
-       asx_parse_param(parser,attribs,repeat);
-     } else
-       MSG_DBG2("Ignoring element %s\n",element);
-    if(body) delete body;
-     asx_free_attribs(attribs);
-  }
 
-  if(!list) {
-    play_tree_free(repeat,1);
-    return NULL;
-  }
-  play_tree_set_child(repeat,list);
+    if(strcasecmp(element,"ASX") != 0) {
+	MSG_ERR("first element isn't ASX, it's %s\n",element);
+	asx_free_attribs(asx_attribs);
+	if(body) delete body;
+	delete &parser;
+	return NULL;
+    }
 
-  return repeat;
+    if(!asx_body) {
+	MSG_ERR("ASX element is empty");
+	asx_free_attribs(asx_attribs);
+	delete &parser;
+	return NULL;
+    }
 
-}
+    asx = play_tree_new();
+    buffer = asx_body;
+    while(buffer && buffer[0] != '\0') {
+	r = parser.get_element(&buffer,&element,&body,&attribs);
+	if(r < 0) {
+	    parser.warning_body_parse_error("ASX");
+	    delete &parser;
+	    return NULL;
+	} else if (r == 0) break; // No more element
+	if(strcasecmp(element,"ENTRY") == 0) {
+	    pt_entry = parser.entry(body,attribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to asx\n",element);
+	    }
+	} else if(strcasecmp(element,"ENTRYREF") == 0) {
+	    pt_entry = parser.entryref(libinput,body,attribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to asx\n",element);
+	    }
+	} else if(strcasecmp(element,"REPEAT") == 0) {
+	    pt_entry = parser.repeat(libinput,body,attribs);
+	    if(pt_entry) {
+		if(!list) list = pt_entry;
+		else play_tree_append_entry(list,pt_entry);
+		MSG_DBG2("Adding element %s to asx\n",element);
+	    }
+	} else MSG_DBG2("Ignoring element %s\n",element);
+	if(body) delete body;
+	asx_free_attribs(attribs);
+    }
 
-play_tree_t* __FASTCALL__ asx_parser_build_tree(libinput_t*libinput,const char* buffer,int deep) {
-  char *element,*asx_body,**asx_attribs,*body, **attribs;
-  int r;
-  play_tree_t *asx,*entry,*list = NULL;
-  ASX_Parser_t* parser = asx_parser_new();
-
-  parser->line = 1;
-  parser->deep = deep;
-
-   r = asx_get_element(parser,&buffer,&element,&asx_body,&asx_attribs);
-  if(r < 0) {
-    MSG_ERR("At line %d : Syntax error ???",parser->line);
-    asx_parser_free(parser);
-    return NULL;
-  } else if(r == 0) { // No contents
-    MSG_ERR("empty asx element");
-    asx_parser_free(parser);
-    return NULL;
-  }
-
-  if(strcasecmp(element,"ASX") != 0) {
-    MSG_ERR("first element isn't ASX, it's %s\n",element);
+    delete asx_body;
     asx_free_attribs(asx_attribs);
-    if(body) delete body;
-    asx_parser_free(parser);
-    return NULL;
-  }
+    delete &parser;
 
-  if(!asx_body) {
-    MSG_ERR("ASX element is empty");
-    asx_free_attribs(asx_attribs);
-    asx_parser_free(parser);
-    return NULL;
-  }
-
-  asx = play_tree_new();
-  buffer = asx_body;
-  while(buffer && buffer[0] != '\0') {
-    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
-     if(r < 0) {
-       asx_warning_body_parse_error(parser,"ASX");
-       asx_parser_free(parser);
-       return NULL;
-     } else if (r == 0) { // No more element
-       break;
-     }
-     if(strcasecmp(element,"ENTRY") == 0) {
-       entry = asx_parse_entry(parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to asx\n",element);
-       }
-     } else if(strcasecmp(element,"ENTRYREF") == 0) {
-       entry = asx_parse_entryref(libinput,parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to asx\n",element);
-       }
-     } else if(strcasecmp(element,"REPEAT") == 0) {
-       entry = asx_parse_repeat(libinput,parser,body,attribs);
-       if(entry) {
-	 if(!list) list =  entry;
-	 else play_tree_append_entry(list,entry);
-	 MSG_DBG2("Adding element %s to asx\n",element);
-       }
-     } else
-       MSG_DBG2("Ignoring element %s\n",element);
-     if(body) delete body;
-     asx_free_attribs(attribs);
-  }
-
-  delete asx_body;
-  asx_free_attribs(asx_attribs);
-  asx_parser_free(parser);
-
-
-  if(!list) {
-    play_tree_free(asx,1);
-
-    return NULL;
-  }
-
-  play_tree_set_child(asx,list);
-
-  return asx;
+    if(!list) {
+	play_tree_free(asx,1);
+	return NULL;
+    }
+    play_tree_set_child(asx,list);
+    return asx;
 }
+} // namespace mpxp

Modified: mplayerxp/libplaytree/asxparser.h
===================================================================
--- mplayerxp/libplaytree/asxparser.h	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/libplaytree/asxparser.h	2012-12-12 09:07:39 UTC (rev 547)
@@ -6,35 +6,43 @@
 
 using namespace mpxp;
 
-typedef struct _ASX_Parser_t ASX_Parser_t;
+namespace mpxp {
+    struct ASX_LineSave_t {
+	const char* buffer;
+	int line;
+    };
 
-typedef struct {
-  const char* buffer;
-  int line;
-} ASX_LineSave_t;
+    class ASX_Parser : public Opaque {
+	public:
+	    ASX_Parser();
+	    virtual ~ASX_Parser();
 
-struct _ASX_Parser_t {
-  int line; // Curent line
-  ASX_LineSave_t *ret_stack;
-  int ret_stack_size;
-  char* last_body;
-  int deep;
-};
+	    static play_tree_t*	build_tree(libinput_t* libinput,const char* buffer, int ref);
 
-extern play_tree_t* __FASTCALL__ asx_parser_build_tree(libinput_t* libinput,const char* buffer, int ref);
+	    virtual int		parse_attribs(char* buffer,char*** _attribs);
+	    /*
+	     * Return -1 on error, 0 when nothing is found, 1 on sucess
+	     */
+	    virtual int		get_element(const char** _buffer,char** _element,char** _body,char*** _attribs);
+	    int			get_line() const { return line; }
+	private:
+	    play_tree_t*	repeat(libinput_t*libinput,const char* buffer,char** _attribs);
+	    void		warning_attrib_invalid(char* elem, char* attrib,const char** valid_vals,char* val);
+	    void		warning_attrib_required(const char *e, const char *a);
+	    void		warning_body_parse_error(const char *e);
+	    int			get_yes_no_attrib(char* element, char* attrib,char** attribs,int def);
+	    void		param(char** attribs, play_tree_t* pt);
+	    void		ref(char** attribs, play_tree_t* pt);
+	    play_tree_t*	entryref(libinput_t* libinput,char* buffer,char** _attribs);
+	    play_tree_t*	entry(const char* buffer,char** _attribs);
 
-extern ASX_Parser_t* asx_parser_new(void);
+	    int			line; // Curent line
+	    ASX_LineSave_t*	ret_stack;
+	    int			ret_stack_size;
+	    char*		last_body;
+	    int			deep;
+};
 
-extern void __FASTCALL__ asx_parser_free(ASX_Parser_t* parser);
-
-/*
- * Return -1 on error, 0 when nothing is found, 1 on sucess
- */
-extern int __FASTCALL__ asx_get_element(ASX_Parser_t* parser,const char** _buffer,
-		char** _element,char** _body,char*** _attribs);
-
-extern int __FASTCALL__ asx_parse_attribs(ASX_Parser_t* parser,char* buffer,char*** _attribs);
-
 /////// Attribs utils
 
 extern char* __FASTCALL__ asx_get_attrib(const char* attrib,char** attribs);
@@ -48,5 +56,5 @@
 extern void __FASTCALL__ asx_list_free(any_t* list_ptr,ASX_FreeFunc free_func);
 
 static inline void asx_free_attribs(any_t*a) { asx_list_free(&a,mp_free); }
-
+} // namespace mpxp
 #endif

Modified: mplayerxp/libplaytree/playtreeparser.cpp
===================================================================
--- mplayerxp/libplaytree/playtreeparser.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/libplaytree/playtreeparser.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -179,7 +179,7 @@
     /* NOTHING */;
 
  MSG_DBG3("Parsing asx file : [%s]\n",p->buffer);
- return asx_parser_build_tree(libinput,p->buffer,p->deep);
+ return ASX_Parser::build_tree(libinput,p->buffer,p->deep);
 }
 
 static char* __FASTCALL__ pls_entry_get_value(char* line) {

Modified: mplayerxp/mplayerxp.cpp
===================================================================
--- mplayerxp/mplayerxp.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/mplayerxp.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -420,7 +420,7 @@
     MP_UNIT(NULL);
 }
 
-void exit_player(const char* why){
+void exit_player(const std::string& why){
 
     fflush(stdout);
     fflush(stderr);
@@ -428,11 +428,11 @@
 
     MP_UNIT("exit_player");
 
-    if(why) MSG_HINT(MSGTR_Exiting,why);
+    if(!why.empty()) MSG_HINT(MSGTR_Exiting,why.c_str());
     if(mpxp_context().mconfig) m_config_free(mpxp_context().mconfig);
     mpxp_print_uninit();
     mpxp_uninit_structs();
-    if(why) exit(0);
+    if(!why.empty()) exit(0);
     return; /* Still try coredump!!!*/
 }
 
@@ -447,7 +447,7 @@
     kill(getpid(),SIGKILL);
     return;
   }
-  exit_player(NULL);
+  exit_player("");
 }
 
 

Modified: mplayerxp/mplayerxp.h
===================================================================
--- mplayerxp/mplayerxp.h	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/mplayerxp.h	2012-12-12 09:07:39 UTC (rev 547)
@@ -1,6 +1,8 @@
 #ifndef __MPLAYERXP_MAIN
 #define __MPLAYERXP_MAIN 1
 
+#include <string>
+
 #include <pthread.h>
 #include <stdint.h>
 #include <string.h>
@@ -177,21 +179,20 @@
 
     extern pthread_mutex_t audio_timer_mutex;
 
-    void exit_player(const char* why);
+    void exit_player(const std::string& why);
 
     /* 10 ms or 10'000 microsecs is optimal time for thread sleeping */
-    inline int yield_timeslice() { return usleep(10000); }
+    inline int yield_timeslice() { return ::usleep(10000); }
 
-    inline void escape_player(const char* why,unsigned num_calls) {
+    inline void escape_player(const std::string& why,unsigned num_calls) {
 	show_backtrace(why,num_calls);
 	exit_player(why);
     }
 
-    inline MPXP_Rc check_pin(const char* module,unsigned pin1,unsigned pin2) {
+    inline MPXP_Rc check_pin(const std::string& module,unsigned pin1,unsigned pin2) {
 	if(pin1!=pin2) {
-	    char msg[4096];
-	    strcpy(msg,"Found incorrect PIN in module: ");
-	    strcat(msg,module);
+	    std::string msg;
+	    msg=std::string("Found incorrect PIN in module: ")+module;
 	    escape_player(msg,mp_conf.max_trace);
 	}
 	return MPXP_Ok;

Modified: mplayerxp/osdep/aclib.cpp
===================================================================
--- mplayerxp/osdep/aclib.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/osdep/aclib.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -24,7 +24,7 @@
   see aclib_template.c ... this file only contains runtime cpu detection and config options stuff
   runtime cpu detection by michael niedermayer (mic...@gm...) is under GPL
 */
-
+namespace mpxp {
 static any_t* init_fast_memcpy(any_t* to, const any_t* from, size_t len)
 {
 #ifdef __SSE2__
@@ -89,13 +89,13 @@
 #endif
 	{
 		MSG_V("Using generic optimized agpcpy\n");
-		fast_stream_copy_ptr = memcpy; /* prior to mmx we use the standart memcpy */
+		fast_stream_copy_ptr = ::memcpy; /* prior to mmx we use the standart memcpy */
 	}
 	return (*fast_stream_copy_ptr)(to,from,len);
 }
 
 any_t*(*fast_memcpy_ptr)(any_t* to, const any_t* from, size_t len) = init_fast_memcpy;
 any_t*(*fast_stream_copy_ptr)(any_t* to, const any_t* from, size_t len) = init_stream_copy;
-
+} // namespace mpxp
 #endif /* use fastmemcpy */
 

Modified: mplayerxp/osdep/aclib_template.h
===================================================================
--- mplayerxp/osdep/aclib_template.h	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/osdep/aclib_template.h	2012-12-12 09:07:39 UTC (rev 547)
@@ -157,6 +157,7 @@
     return retval;\
 }
 
+namespace mpxp {
 #undef MEM_STORE
 #undef MEM_SFENCE
 #define MEM_STORE  _ivec_stream
@@ -176,4 +177,5 @@
     MSG_DBG3("fast_memcpy(%p, %p, %u) [cl_size=%u]\n",to,from,len,gCpuCaps.cl_size);
     FAST_MEMORY_COPY(to,from,len);
 }
+} // namesapce mpxp
 #endif

Modified: mplayerxp/osdep/fastmemcpy.h
===================================================================
--- mplayerxp/osdep/fastmemcpy.h	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/osdep/fastmemcpy.h	2012-12-12 09:07:39 UTC (rev 547)
@@ -1,55 +1,51 @@
 #ifndef __MPLAYER_MEMCPY
 #define __MPLAYER_MEMCPY 1
+#include "mp_config.h"
+using namespace mpxp;
 
-#include "../mp_config.h"
-
 #ifdef USE_FASTMEMCPY
 #include <stddef.h>
 #include <string.h> /* memcpy prototypes */
-extern any_t* (*fast_memcpy_ptr)(any_t* to, const any_t* from, size_t len);
-extern any_t* (*fast_stream_copy_ptr)(any_t* to, const any_t* from, size_t len);
+namespace mpxp {
+    extern any_t* (*fast_memcpy_ptr)(any_t* to, const any_t* from, size_t len);
+    extern any_t* (*fast_stream_copy_ptr)(any_t* to, const any_t* from, size_t len);
 #define memcpy(a,b,c) (*fast_memcpy_ptr)(a,b,c)
 #define stream_copy(a,b,c) (*fast_stream_copy_ptr)(a,b,c)
 #else
-#define stream_copy(a,b,c) memcpy(a,b,c)
+#define stream_copy(a,b,c) ::memcpy(a,b,c)
 #endif
 
-static inline any_t* stream_copy_pic(any_t* dst, const any_t* src, int bytesPerLine, int height, int dstStride, int srcStride)
-{
+    inline any_t* stream_copy_pic(any_t* dst, const any_t* src, int bytesPerLine, int height, int dstStride, int srcStride)
+    {
 	int i;
 	any_t*retval=dst;
 
 	if(dstStride == srcStride) stream_copy(dst, src, srcStride*height);
-	else
-	{
-		for(i=0; i<height; i++)
-		{
-			stream_copy(dst, src, bytesPerLine);
-			src=(char *)src+ srcStride;
-			dst=(char *)dst+ dstStride;
-		}
+	else {
+	    for(i=0; i<height; i++) {
+		stream_copy(dst, src, bytesPerLine);
+		src=(char *)src+ srcStride;
+		dst=(char *)dst+ dstStride;
+	    }
 	}
 
 	return retval;
-}
+    }
 
-static inline any_t* memcpy_pic(any_t* dst, const any_t* src, int bytesPerLine, int height, int dstStride, int srcStride)
-{
+    inline any_t* memcpy_pic(any_t* dst, const any_t* src, int bytesPerLine, int height, int dstStride, int srcStride)
+    {
 	int i;
 	any_t*retval=dst;
 
 	if(dstStride == srcStride) memcpy(dst, src, srcStride*height);
-	else
-	{
-		for(i=0; i<height; i++)
-		{
-			memcpy(dst, src, bytesPerLine);
-			src=(char *)src+ srcStride;
-			dst=(char *)dst+ dstStride;
-		}
+	else {
+	    for(i=0; i<height; i++) {
+		memcpy(dst, src, bytesPerLine);
+		src=(char *)src+ srcStride;
+		dst=(char *)dst+ dstStride;
+	    }
 	}
-
 	return retval;
-}
-
+    }
+} // namespace mpxp
 #endif

Modified: mplayerxp/osdep/mp_malloc.cpp
===================================================================
--- mplayerxp/osdep/mp_malloc.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/osdep/mp_malloc.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -211,10 +211,10 @@
     uninit_bt_cache(cache);
 }
 
-void print_backtrace(const char *why,any_t** stack,unsigned num) {
+void print_backtrace(const std::string& why,any_t** stack,unsigned num) {
     char result[4096];
     unsigned	i;
-    MSG_INFO(why?why:"*** Backtrace for suspect call ***\n");
+    MSG_INFO(!why.empty()?why.c_str():"*** Backtrace for suspect call ***\n");
     for(i=0;i<num;i++) {
 	MSG_INFO("    %p -> %s\n",stack[i],exec_addr2line(stack[i],result,sizeof(result)));
     }

Modified: mplayerxp/osdep/mplib.h
===================================================================
--- mplayerxp/osdep/mplib.h	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/osdep/mplib.h	2012-12-12 09:07:39 UTC (rev 547)
@@ -8,6 +8,9 @@
  */
 #ifndef __MPLIB_H_INCLUDED__
 #define __MPLIB_H_INCLUDED__ 1
+
+#include <string>
+
 #include <execinfo.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ -62,9 +65,9 @@
 	MP_DENY_ALL		=0x0,	/* Page can not be accessed.  */
     };
     int	__FASTCALL__ mp_mprotect(any_t* addr,size_t len,enum mp_prot_e flags);
-    void print_backtrace(const char *why,any_t** stack,unsigned num);
+    void print_backtrace(const std::string& why,any_t** stack,unsigned num);
 
-    inline void show_backtrace(const char *why,unsigned num_calls) {
+    inline void show_backtrace(const std::string& why,unsigned num_calls) {
 	any_t*	stack[num_calls];
 	unsigned ncalls;
 	ncalls=backtrace(stack,num_calls);

Modified: mplayerxp/postproc/libmenu/menu.cpp
===================================================================
--- mplayerxp/postproc/libmenu/menu.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/postproc/libmenu/menu.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -62,22 +62,22 @@
   char *element,*body, **attribs, *name;
   menu_info_t* minfo = NULL;
   int r,i;
-  ASX_Parser_t* parser = asx_parser_new();
+  ASX_Parser& parser = *new(zeromem) ASX_Parser;
 
   while(1) {
-    r = asx_get_element(parser,&buffer,&element,&body,&attribs);
+    r = parser.get_element(&buffer,&element,&body,&attribs);
     if(r < 0) {
-      MSG_WARN("[libmenu] Syntax error at line: %i\n",parser->line);
-      asx_parser_free(parser);
+      MSG_WARN("[libmenu] Syntax error at line: %i\n",parser.get_line());
+      delete &parser;
       return 0;
     } else if(r == 0) {
-      asx_parser_free(parser);
+      delete &parser;
       return 1;
     }
     // Has it a name ?
     name = asx_get_attrib("name",attribs);
     if(!name) {
-      MSG_WARN("[libmenu] Menu definitions need a name attrib: %i\n",parser->line);
+      MSG_WARN("[libmenu] Menu definitions need a name attrib: %i\n",parser.get_line());
       delete element;
       if(body) delete body;
       asx_free_attribs(attribs);
@@ -103,12 +103,12 @@
 	if(strcasecmp(attribs[2*i],"name") == 0) continue;
 	if(!m_struct_set(&minfo->priv_st,menu_list[menu_count].cfg,attribs[2*i], attribs[2*i+1]))
 	  MSG_WARN("[libmenu] Bad attrib: %s %s %s %i\n",attribs[2*i],attribs[2*i+1],
-		 name,parser->line);
+		 name,parser.get_line());
       }
       menu_count++;
       memset(&menu_list[menu_count],0,sizeof(menu_def_t));
     } else {
-      MSG_WARN("[libmenu] Unknown menu type: %s %i\n",element,parser->line);
+      MSG_WARN("[libmenu] Unknown menu type: %s %i\n",element,parser.get_line());
       delete name;
       if(body) delete body;
     }
@@ -116,7 +116,8 @@
     delete element;
     asx_free_attribs(attribs);
   }
-
+  delete &parser;
+  return 0;
 }
 
 /// This will build the menu_defs list from the cfg file

Modified: mplayerxp/postproc/libmenu/menu_cmdlist.cpp
===================================================================
--- mplayerxp/postproc/libmenu/menu_cmdlist.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/postproc/libmenu/menu_cmdlist.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -112,16 +112,16 @@
   char *element,*body, **attribs, *name;
   list_entry_t* m = NULL;
   int r;
-  ASX_Parser_t* parser = asx_parser_new();
+  ASX_Parser& parser = *new(zeromem) ASX_Parser;
 
   while(1) {
-    r = asx_get_element(parser,&args,&element,&body,&attribs);
+    r = parser.get_element(&args,&element,&body,&attribs);
     if(r < 0) {
-      MSG_WARN("[libmenu] Syntax error at line: %i\n",parser->line);
-      asx_parser_free(parser);
+      MSG_WARN("[libmenu] Syntax error at line: %i\n",parser.get_line());
+      delete &parser;
       return -1;
     } else if(r == 0) {
-      asx_parser_free(parser);
+      delete &parser;
       if(!m)
 	MSG_WARN("[libmenu] No entry found in the menu definition\n");
       return m ? 1 : 0;
@@ -129,7 +129,7 @@
     // Has it a name ?
     name = asx_get_attrib("name",attribs);
     if(!name) {
-      MSG_WARN("[libmenu] ListMenu entry definitions need a name: %i\n",parser->line);
+      MSG_WARN("[libmenu] ListMenu entry definitions need a name: %i\n",parser.get_line());
       delete element;
       if(body) delete body;
       asx_free_attribs(attribs);
@@ -147,6 +147,8 @@
     if(body) delete body;
     asx_free_attribs(attribs);
   }
+  delete &parser;
+  return -1;
 }
 
 static int open_cmdlist(menu_t* menu, const char* args) {

Modified: mplayerxp/postproc/libmenu/menu_param.cpp
===================================================================
--- mplayerxp/postproc/libmenu/menu_param.cpp	2012-12-11 17:07:00 UTC (rev 546)
+++ mplayerxp/postproc/libmenu/menu_param.cpp	2012-12-12 09:07:39 UTC (rev 547)
@@ -96,17 +96,16 @@
   list_entry_t* m = NULL;
   int r;
   m_option_t* opt;
-  ASX_Parser_t* parser = asx_parser_new();
+  ASX_Parser& parser = *new(zeromem) ASX_Parser;
 
-
   while(1) {
-    r = asx_get_element(parser,&args,&element,&body,&attribs);
+    r = parser.get_element(&args,&element,&body,&attribs);
     if(r < 0) {
-      MSG_ERR("[libmenu] Syntax error at line: %s\n",parser->line);
-      asx_parser_free(parser);
+      MSG_ERR("[libmenu] Syntax error at line: %s\n",parser.get_line());
+      delete &parser;
       return -1;
     } else if(r == 0) {
-      asx_parser_free(parser);
+      delete &parser;
       if(!m)
 	MSG_WARN("[libmenu] No entry found in the menu definition\n");
       m = new(zeromem) struct list_entry_s;
@@ -133,12 +132,12 @@
     opt = NULL;
     if(name && mp_property_do(name,M_PROPERTY_GET_TYPE,&opt,menu->ctx) <= 0) {
       MSG_WARN("[libmenu] Invalid property: %s %i\n",
-	     name,parser->line);
+	     name,parser.get_line());
       goto next_element;
     }
     txt = asx_get_attrib("txt",attribs);
     if(!(name || txt)) {
-      MSG_WARN("[libmenu] PrefMenu entry definitions need: %i\n",parser->line);
+      MSG_WARN("[libmenu] PrefMenu entry definitions need: %i\n",parser.get_line());
       if(txt) { delete txt; txt = NULL; }
       goto next_element;
     }
@@ -157,6 +156,8 @@
     if(name) delete name;
     asx_free_attribs(attribs);
   }
+  delete &parser;
+  return -1;
 }
 
 static void read_key(menu_t* menu,int c) {

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.