Merge from 1.1 (with adaptations).

--HG--
rename : src/xine-engine/scratch.h => include/xine/scratch.h
rename : src/xine-utils/xmllexer.h => include/xine/xmllexer.h
rename : src/xine-utils/xmlparser.h => include/xine/xmlparser.h
rename : src/libspucmml/xine_cmml_decoder.c => src/spu_dec/cmml_decoder.c
rename : src/libspuhdmv/xine_hdmv_decoder.c => src/spu_dec/spuhdmv_decoder.c

1 files changed, 90 insertions, 75 deletions

diff --git a/src/xine-utils/xmllexer.c b/src/xine-utils/xmllexer.c
index a535b7aca..c37510903 100644
--- a/src/xine-utils/xmllexer.c
+++ b/src/xine-utils/xmllexer.c
@@ -48,15 +48,11 @@
 /* private constants*/
 
 /* private global variables */
-static const char * lexbuf;
-static int lexbuf_size = 0;
-static int lexbuf_pos  = 0;
-static int in_comment  = 0;
-static char *lex_malloc = NULL;
+struct lexer * static_lexer;
 
 enum utf { UTF32BE, UTF32LE, UTF16BE, UTF16LE };
 
-static void lex_convert (const char * buf, int size, enum utf utf)
+static void lex_convert (struct lexer * lexer, const char * buf, int size, enum utf utf)
 {
   char *utf8 = malloc (size * (utf >= UTF16BE ? 3 : 6) + 1);
   char *bp = utf8;
@@ -88,8 +84,16 @@ static void lex_convert (const char * buf, int size, enum utf utf)
     }
   }
   *bp = 0;
-  lexbuf_size = bp - utf8;
-  lexbuf = lex_malloc = realloc (utf8, lexbuf_size + 1);
+  lexer->lexbuf_size = bp - utf8;
+  lexer->lexbuf = lexer->lex_malloc = realloc (utf8, lexer->lexbuf_size + 1);
+}
+
+/* for ABI compatibility */
+void lexer_init(const char * buf, int size) {
+  if (static_lexer) {
+    lexer_finalize_r(static_lexer);
+  }
+  static_lexer = lexer_init_r(buf, size);
 }
 
 static enum {
@@ -98,35 +102,40 @@ static enum {
   CDATA,
 } lex_mode = NORMAL;
 
-void lexer_init(const char * buf, int size) {
+struct lexer *lexer_init_r(const char * buf, int size) {
   static const char boms[] = { 0xFF, 0xFE, 0, 0, 0xFE, 0xFF },
 		    bom_utf8[] = { 0xEF, 0xBB, 0xBF };
+  struct lexer * lexer = calloc (1, sizeof (*lexer));
 
-  free (lex_malloc);
-  lex_malloc = NULL;
-
-  lexbuf      = buf;
-  lexbuf_size = size;
+  lexer->lexbuf      = buf;
+  lexer->lexbuf_size = size;
 
   if (size >= 4 && !memcmp (buf, boms + 2, 4))
-    lex_convert (buf + 4, size - 4, UTF32BE);
+    lex_convert (lexer, buf + 4, size - 4, UTF32BE);
   else if (size >= 4 && !memcmp (buf, boms, 4))
-    lex_convert (buf + 4, size - 4, UTF32LE);
+    lex_convert (lexer, buf + 4, size - 4, UTF32LE);
   else if (size >= 3 && !memcmp (buf, bom_utf8, 3))
   {
-    lexbuf += 3;
-    lexbuf_size -= 3;
+    lexer->lexbuf += 3;
+    lexer->lexbuf_size -= 3;
   }
   else if (size >= 2 && !memcmp (buf, boms + 4, 2))
-    lex_convert (buf + 2, size - 2, UTF16BE);
+    lex_convert (lexer, buf + 2, size - 2, UTF16BE);
   else if (size >= 2 && !memcmp (buf, boms, 2))
-    lex_convert (buf + 2, size - 2, UTF16LE);
+    lex_convert (lexer, buf + 2, size - 2, UTF16LE);
 
-  lexbuf_pos  = 0;
-  lex_mode    = NORMAL;
-  in_comment  = 0;
+  lexer->lexbuf_pos  = 0;
+  lexer->lex_mode    = NORMAL;
+  lexer->in_comment  = 0;
 
   lprintf("buffer length %d\n", size);
+  return lexer;
+}
+
+void lexer_finalize_r(struct lexer * lexer)
+{
+  free(lexer->lex_malloc);
+  free(lexer);
 }
 
 typedef enum {
@@ -147,19 +156,25 @@ typedef enum {
   STATE_IDENT /* must be last */
 } lexer_state_t;
 
+/* for ABI compatibility */
 int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
+  return lexer_get_token_d_r(static_lexer, _tok, _tok_size, fixed);
+}
+
+int lexer_get_token_d_r(struct lexer * lexer, char ** _tok, int * _tok_size, int fixed) {
   char *tok = *_tok;
   int tok_size = *_tok_size;
+
   int tok_pos = 0;
   lexer_state_t state = STATE_IDLE;
   char c;
 
   if (tok) {
-    while ((tok_pos < tok_size) && (lexbuf_pos < lexbuf_size)) {
-      c = lexbuf[lexbuf_pos];
-      lprintf("c=%c, state=%d, lex_mode=%d, in_comment=%d\n", c, state, lex_mode, in_comment);
+    while ((tok_pos < tok_size) && (lexer->lexbuf_pos < lexer->lexbuf_size)) {
+      c = lexer->lexbuf[lexer->lexbuf_pos];
+      lprintf("c=%c, state=%d, in_comment=%d\n", c, state, lexer->in_comment);
 
-      switch (lex_mode) {
+      switch (lexer->lex_mode) {
       case NORMAL:
 	switch (state) {
 	  /* init state */
@@ -192,7 +207,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	    break;
 
 	  case '/':
-	    if (!in_comment) 
+	    if (!lexer->in_comment) 
 	      state = STATE_T_M_STOP_2;
 	    tok[tok_pos] = c;
 	    tok_pos++;
@@ -219,7 +234,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	    break;
 
 	  case '?':
-	    if (!in_comment)
+	    if (!lexer->in_comment)
 	      state = STATE_T_TI_STOP;
 	    tok[tok_pos] = c;
 	    tok_pos++;
@@ -231,14 +246,14 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	    tok_pos++;
 	    break;
 	  }
-	  lexbuf_pos++;
+	  lexer->lexbuf_pos++;
 	  break;
 
 	  /* end of line */
 	case STATE_EOL:
 	  if (c == '\n' || (c == '\r')) {
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++;
 	  } else {
 	    tok[tok_pos] = '\0';
@@ -250,7 +265,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	case STATE_SEPAR:
 	  if (c == ' ' || (c == '\t')) {
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++;
 	  } else {
 	    tok[tok_pos] = '\0';
@@ -263,20 +278,20 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  switch (c) {
 	  case '/':
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++; /* FIXME */
 	    tok[tok_pos] = '\0';
 	    return T_M_START_2;
 	    break;
 	  case '!':
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++;
 	    state = STATE_T_COMMENT;
 	    break;
 	  case '?':
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++; /* FIXME */
 	    tok[tok_pos] = '\0';
 	    return T_TI_START;
@@ -290,8 +305,8 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  /* T_M_STOP_1 */
 	case STATE_T_M_STOP_1:
 	  tok[tok_pos] = '\0';
-	  if (!in_comment)
-	    lex_mode = DATA;
+	  if (!lexer->in_comment)
+	    lexer->lex_mode = DATA;
 	  return T_M_STOP_1;
 	  break;
 
@@ -299,11 +314,11 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	case STATE_T_M_STOP_2:
 	  if (c == '>') {
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++; /* FIXME */
 	    tok[tok_pos] = '\0';
-	    if (!in_comment)
-	      lex_mode = DATA;
+	    if (!lexer->in_comment)
+	      lexer->lex_mode = DATA;
 	    return T_M_STOP_2;
 	  } else {
 	    tok[tok_pos] = '\0';
@@ -320,7 +335,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  /* T_STRING */
 	case STATE_T_STRING_DOUBLE:
 	  tok[tok_pos] = c;
-	  lexbuf_pos++;
+	  lexer->lexbuf_pos++;
 	  if (c == '\"') { /* " */
 	    tok[tok_pos] = '\0'; /* FIXME */
 	    return T_STRING;
@@ -332,33 +347,33 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	case STATE_T_COMMENT:
 	  switch (c) {
 	  case '-':
-	    lexbuf_pos++;
-	    if (lexbuf[lexbuf_pos] == '-')
+	    lexer->lexbuf_pos++;
+	    if (lexer->lexbuf[lexer->lexbuf_pos] == '-')
 	      {
-		lexbuf_pos++;
+		lexer->lexbuf_pos++;
 		tok[tok_pos++] = '-'; /* FIXME */
 		tok[tok_pos++] = '-';
 		tok[tok_pos] = '\0';
-		in_comment = 1;
+		lexer->in_comment = 1;
 		return T_C_START;
 	      }
 	    break;
 	  case 'D':
-	    lexbuf_pos++;
-	    if (strncmp(lexbuf + lexbuf_pos, "OCTYPE", 6) == 0) {
+	    lexer->lexbuf_pos++;
+	    if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "OCTYPE", 6) == 0) {
 	      strncpy(tok + tok_pos, "DOCTYPE", 7); /* FIXME */
-	      lexbuf_pos += 6;
+	      lexer->lexbuf_pos += 6;
 	      return T_DOCTYPE_START;
 	    } else {
 	      return T_ERROR;
 	    }
 	    break;
 	  case '[':
-	    lexbuf_pos++;
-	    if (strncmp(lexbuf + lexbuf_pos, "CDATA[", 6) == 0) {
+	    lexer->lexbuf_pos++;
+	    if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "CDATA[", 6) == 0) {
 	      strncpy (tok + tok_pos, "[CDATA[", 7); /* FIXME */
-	      lexbuf_pos += 6;
-	      lex_mode = CDATA;
+	      lexer->lexbuf_pos += 6;
+	      lexer->lex_mode = CDATA;
 	      return T_CDATA_START;
 	    } else{
 	      return T_ERROR;
@@ -374,11 +389,11 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	case STATE_T_TI_STOP:
 	  if (c == '>') {
 	    tok[tok_pos] = c;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok_pos++; /* FIXME */
 	    tok[tok_pos] = '\0';
-	    if (!in_comment)
-	      lex_mode = DATA;
+	    if (!lexer->in_comment)
+	      lexer->lex_mode = DATA;
 	    return T_TI_STOP;
 	  } else {
 	    tok[tok_pos] = '\0';
@@ -392,13 +407,13 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  case '-':
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    state = STATE_T_C_STOP;
 	    break;
 	  default:
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    state = STATE_IDENT;
 	  }
 	  break;
@@ -409,21 +424,21 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  case '>':
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    tok[tok_pos] = '\0'; /* FIX ME */
 	    if (strlen(tok) != 3) {
 	      tok[tok_pos - 3] = '\0';
-	      lexbuf_pos -= 3;
+	      lexer->lexbuf_pos -= 3;
 	      return T_IDENT;
 	    } else {
-	      in_comment = 0;
+	      lexer->in_comment = 0;
 	      return T_C_STOP;
 	    }
 	    break;
 	  default:
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    state = STATE_IDENT;
 	  }
 	  break;
@@ -431,7 +446,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  /* T_STRING (single quotes) */
 	case STATE_T_STRING_SINGLE:
 	  tok[tok_pos] = c;
-	  lexbuf_pos++;
+	  lexer->lexbuf_pos++;
 	  if (c == '\'') { /* " */
 	    tok[tok_pos] = '\0'; /* FIXME */
 	    return T_STRING;
@@ -458,19 +473,19 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
 	  case '?':
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    state = STATE_T_TI_STOP;
 	    break;
 	  case '-':
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	    state = STATE_T_DASHDASH;
 	    break;
 	  default:
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	  }
 	  break;
 	default:
@@ -484,12 +499,12 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
         {
         case '<':
 	  tok[tok_pos] = '\0';
-	  lex_mode = NORMAL;
+	  lexer->lex_mode = NORMAL;
 	  return T_DATA;
 	default:
 	  tok[tok_pos] = c;
 	  tok_pos++;
-	  lexbuf_pos++;
+	  lexer->lexbuf_pos++;
 	}
 	break;
 
@@ -497,26 +512,26 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
         switch (c)
         {
 	case ']':
-	  if (strncmp(lexbuf + lexbuf_pos, "]]>", 3) == 0) {
-	    lexbuf_pos += 3;
-	    lex_mode = DATA;
+	  if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "]]>", 3) == 0) {
+	    lexer->lexbuf_pos += 3;
+	    lexer->lex_mode = DATA;
 	    return T_CDATA_STOP;
 	  } else {
 	    tok[tok_pos] = c;
 	    tok_pos++;
-	    lexbuf_pos++;
+	    lexer->lexbuf_pos++;
 	  }
 	  break;
 	default:
 	  tok[tok_pos] = c;
 	  tok_pos++;
-	  lexbuf_pos++;
+	  lexer->lexbuf_pos++;
 	}
 	break;
       }
     }
     lprintf ("loop done tok_pos = %d, tok_size=%d, lexbuf_pos=%d, lexbuf_size=%d\n", 
-	     tok_pos, tok_size, lexbuf_pos, lexbuf_size);
+	     tok_pos, tok_size, lexer->lexbuf_pos, lexer->lexbuf_size);
 
     /* pb */
     if (tok_pos >= tok_size) {
@@ -527,12 +542,12 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
       lprintf("token buffer is too small\n");
       lprintf("increasing buffer size to %d bytes\n", *_tok_size);
       if (*_tok) {
-          return lexer_get_token_d (_tok, _tok_size, 0);
+          return lexer_get_token_d_r (lexer, _tok, _tok_size, 0);
       } else {
           return T_ERROR;
       }
     } else {
-      if (lexbuf_pos >= lexbuf_size) {
+      if (lexer->lexbuf_pos >= lexer->lexbuf_size) {
 				/* Terminate the current token */
 	tok[tok_pos] = '\0';
 	switch (state) {