开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
rpn.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：36k
源码类别：

midi

开发平台：

Unix_Linux

rpn.c：源码内容
  1. /*****************************************************************************
  2.  * rpn.c : RPN evaluator for the HTTP Interface
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2006 the VideoLAN team
  5.  * $Id: 05c30cf4fec935c37eb780621302b20ed0549074 $
  6.  *
  7.  * Authors: Gildas Bazin <gbazin@netcourrier.com>
  8.  *          Laurent Aimar <fenrir@via.ecp.fr>
  9.  *          Christophe Massiot <massiot@via.ecp.fr>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24.  *****************************************************************************/
  25. #ifdef HAVE_CONFIG_H
  26. # include "config.h"
  27. #endif
  29. #include "http.h"
  30. #include "vlc_url.h"
  31. #include "vlc_meta.h"
  32. #include "vlc_strings.h"
  34. static vlc_object_t *GetVLCObject( intf_thread_t *p_intf,
  35.                                    const char *psz_object,
  36.                                    bool *pb_need_release )
  37. {
  38.     intf_sys_t    *p_sys = p_intf->p_sys;
  39.     vlc_object_t *p_object = NULL;
  40.     *pb_need_release = false;
  42.     if( !strcmp( psz_object, "VLC_OBJECT_LIBVLC" ) )
  43.         p_object = VLC_OBJECT(p_intf->p_libvlc);
  44.     else if( !strcmp( psz_object, "VLC_OBJECT_PLAYLIST" ) )
  45.         p_object = VLC_OBJECT(p_sys->p_playlist);
  46.     else if( !strcmp( psz_object, "VLC_OBJECT_INPUT" ) )
  47.         p_object = VLC_OBJECT(p_sys->p_input);
  48.     else if( p_sys->p_input )
  49.     {
  50.         if( !strcmp( psz_object, "VLC_OBJECT_VOUT" ) )
  51.             p_object = VLC_OBJECT( input_GetVout( p_sys->p_input ) );
  52.         else if( !strcmp( psz_object, "VLC_OBJECT_AOUT" ) )
  53.             p_object = VLC_OBJECT( input_GetAout( p_sys->p_input ) );
  54.         if( p_object )
  55.             *pb_need_release = true;
  56.     }
  57.     else
  58.         msg_Warn( p_intf, "unknown object type (%s)", psz_object );
  60.     return p_object;
  61. }
  63. void SSInit( rpn_stack_t *st )
  64. {
  65.     st->i_stack = 0;
  66. }
  68. void SSClean( rpn_stack_t *st )
  69. {
  70.     while( st->i_stack > 0 )
  71.     {
  72.         free( st->stack[--st->i_stack] );
  73.     }
  74. }
  76. void SSPush( rpn_stack_t *st, const char *s )
  77. {
  78.     if( st->i_stack < STACK_MAX )
  79.     {
  80.         st->stack[st->i_stack++] = strdup( s );
  81.     }
  82. }
  84. char *SSPop( rpn_stack_t *st )
  85. {
  86.     if( st->i_stack <= 0 )
  87.     {
  88.         return strdup( "" );
  89.     }
  90.     else
  91.     {
  92.         return st->stack[--st->i_stack];
  93.     }
  94. }
  96. int SSPopN( rpn_stack_t *st, mvar_t  *vars )
  97. {
  98.     char *name;
  100.     char *end;
  101.     int  i;
  103.     name = SSPop( st );
  104.     i = strtol( name, &end, 0 );
  105.     if( end == name )
  106.     {
  107.         const char *value = mvar_GetValue( vars, name );
  108.         i = atoi( value );
  109.     }
  110.     free( name );
  112.     return( i );
  113. }
  115. void SSPushN( rpn_stack_t *st, int i )
  116. {
  117.     char v[12];
  119.     snprintf( v, sizeof (v), "%d", i );
  120.     SSPush( st, v );
  121. }
  123. void EvaluateRPN( intf_thread_t *p_intf, mvar_t  *vars,
  124.                       rpn_stack_t *st, char *exp )
  125. {
  126.     intf_sys_t    *p_sys = p_intf->p_sys;
  128.     while( exp != NULL && *exp != '' )
  129.     {
  130.         char *p, *s;
  132.         /* skip space */
  133.         while( *exp == ' ' )
  134.         {
  135.             exp++;
  136.         }
  138.         if( *exp == ''' )
  139.         {
  140.             /* extract string */
  141.             p = FirstWord( exp, exp );
  142.             SSPush( st, exp );
  143.             exp = p;
  144.             continue;
  145.         }
  147.         /* extract token */
  148.         p = FirstWord( exp, exp );
  149.         s = exp;
  150.         if( p == NULL )
  151.         {
  152.             exp += strlen( exp );
  153.         }
  154.         else
  155.         {
  156.             exp = p;
  157.         }
  159.         if( *s == '' )
  160.         {
  161.             break;
  162.         }
  164.         /* 1. Integer function */
  165.         if( !strcmp( s, "!" ) )
  166.         {
  167.             SSPushN( st, ~SSPopN( st, vars ) );
  168.         }
  169.         else if( !strcmp( s, "^" ) )
  170.         {
  171.             SSPushN( st, SSPopN( st, vars ) ^ SSPopN( st, vars ) );
  172.         }
  173.         else if( !strcmp( s, "&" ) )
  174.         {
  175.             SSPushN( st, SSPopN( st, vars ) & SSPopN( st, vars ) );
  176.         }
  177.         else if( !strcmp( s, "|" ) )
  178.         {
  179.             SSPushN( st, SSPopN( st, vars ) | SSPopN( st, vars ) );
  180.         }
  181.         else if( !strcmp( s, "+" ) )
  182.         {
  183.             SSPushN( st, SSPopN( st, vars ) + SSPopN( st, vars ) );
  184.         }
  185.         else if( !strcmp( s, "-" ) )
  186.         {
  187.             int j = SSPopN( st, vars );
  188.             int i = SSPopN( st, vars );
  189.             SSPushN( st, i - j );
  190.         }
  191.         else if( !strcmp( s, "*" ) )
  192.         {
  193.             SSPushN( st, SSPopN( st, vars ) * SSPopN( st, vars ) );
  194.         }
  195.         else if( !strcmp( s, "/" ) )
  196.         {
  197.             int i, j;
  199.             j = SSPopN( st, vars );
  200.             i = SSPopN( st, vars );
  202.             SSPushN( st, j != 0 ? i / j : 0 );
  203.         }
  204.         else if( !strcmp( s, "%" ) )
  205.         {
  206.             int i, j;
  208.             j = SSPopN( st, vars );
  209.             i = SSPopN( st, vars );
  211.             SSPushN( st, j != 0 ? i % j : 0 );
  212.         }
  213.         /* 2. integer tests */
  214.         else if( !strcmp( s, "=" ) )
  215.         {
  216.             SSPushN( st, SSPopN( st, vars ) == SSPopN( st, vars ) ? -1 : 0 );
  217.         }
  218.         else if( !strcmp( s, "!=" ) )
  219.         {
  220.             SSPushN( st, SSPopN( st, vars ) != SSPopN( st, vars ) ? -1 : 0 );
  221.         }
  222.         else if( !strcmp( s, "<" ) )
  223.         {
  224.             int j = SSPopN( st, vars );
  225.             int i = SSPopN( st, vars );
  227.             SSPushN( st, i < j ? -1 : 0 );
  228.         }
  229.         else if( !strcmp( s, ">" ) )
  230.         {
  231.             int j = SSPopN( st, vars );
  232.             int i = SSPopN( st, vars );
  234.             SSPushN( st, i > j ? -1 : 0 );
  235.         }
  236.         else if( !strcmp( s, "<=" ) )
  237.         {
  238.             int j = SSPopN( st, vars );
  239.             int i = SSPopN( st, vars );
  241.             SSPushN( st, i <= j ? -1 : 0 );
  242.         }
  243.         else if( !strcmp( s, ">=" ) )
  244.         {
  245.             int j = SSPopN( st, vars );
  246.             int i = SSPopN( st, vars );
  248.             SSPushN( st, i >= j ? -1 : 0 );
  249.         }
  250.         /* 3. string functions */
  251.         else if( !strcmp( s, "strcat" ) )
  252.         {
  253.             char *s2 = SSPop( st );
  254.             char *s1 = SSPop( st );
  255.             char *str = malloc( strlen( s1 ) + strlen( s2 ) + 1 );
  257.             strcpy( str, s1 );
  258.             strcat( str, s2 );
  260.             SSPush( st, str );
  261.             free( s1 );
  262.             free( s2 );
  263.             free( str );
  264.         }
  265.         else if( !strcmp( s, "strcmp" ) )
  266.         {
  267.             char *s2 = SSPop( st );
  268.             char *s1 = SSPop( st );
  270.             SSPushN( st, strcmp( s1, s2 ) );
  271.             free( s1 );
  272.             free( s2 );
  273.         }
  274.         else if( !strcmp( s, "strncmp" ) )
  275.         {
  276.             int n = SSPopN( st, vars );
  277.             char *s2 = SSPop( st );
  278.             char *s1 = SSPop( st );
  280.             SSPushN( st, strncmp( s1, s2 , n ) );
  281.             free( s1 );
  282.             free( s2 );
  283.         }
  284.         else if( !strcmp( s, "strsub" ) )
  285.         {
  286.             int n = SSPopN( st, vars );
  287.             int m = SSPopN( st, vars );
  288.             int i_len;
  289.             char *s = SSPop( st );
  290.             char *str;
  292.             if( n >= m )
  293.             {
  294.                 i_len = n - m + 1;
  295.             }
  296.             else
  297.             {
  298.                 i_len = 0;
  299.             }
  301.             str = malloc( i_len + 1 );
  303.             memcpy( str, s + m - 1, i_len );
  304.             str[ i_len ] = '';
  306.             SSPush( st, str );
  307.             free( s );
  308.             free( str );
  309.         }
  310.         else if( !strcmp( s, "strlen" ) )
  311.         {
  312.             char *str = SSPop( st );
  314.             SSPushN( st, strlen( str ) );
  315.             free( str );
  316.         }
  317.         else if( !strcmp( s, "str_replace" ) )
  318.         {
  319.             char *psz_to = SSPop( st );
  320.             char *psz_from = SSPop( st );
  321.             char *psz_in = SSPop( st );
  322.             char *psz_in_current = psz_in;
  323.             char *psz_out = malloc( strlen(psz_in) * strlen(psz_to) + 1 );
  324.             char *psz_out_current = psz_out;
  326.             while( (p = strstr( psz_in_current, psz_from )) != NULL )
  327.             {
  328.                 memcpy( psz_out_current, psz_in_current, p - psz_in_current );
  329.                 psz_out_current += p - psz_in_current;
  330.                 strcpy( psz_out_current, psz_to );
  331.                 psz_out_current += strlen(psz_to);
  332.                 psz_in_current = p + strlen(psz_from);
  333.             }
  334.             strcpy( psz_out_current, psz_in_current );
  335.             psz_out_current += strlen(psz_in_current);
  336.             *psz_out_current = '';
  338.             SSPush( st, psz_out );
  339.             free( psz_to );
  340.             free( psz_from );
  341.             free( psz_in );
  342.             free( psz_out );
  343.         }
  344.         else if( !strcmp( s, "url_extract" ) )
  345.         {
  346.             const char *url = mvar_GetValue( vars, "url_value" );
  347.             char *name = SSPop( st );
  348.             char *value = ExtractURIString( url, name );
  349.             if( value != NULL )
  350.             {
  351.                 decode_URI( value );
  352.                 SSPush( st, value );
  353.                 free( value );
  354.             }
  355.             else
  356.                 SSPush( st, "" );
  358.             free( name );
  359.         }
  360.         else if( !strcmp( s, "url_encode" ) )
  361.         {
  362.             char *url = SSPop( st );
  363.             char *value = vlc_UrlEncode( url );
  364.             free( url );
  365.             SSPush( st, value );
  366.             free( value );
  367.         }
  368.         else if( !strcmp( s, "xml_encode" )
  369.               || !strcmp( s, "htmlspecialchars" ) )
  370.         {
  371.             char *url = SSPop( st );
  372.             char *value = convert_xml_special_chars( url );
  373.             free( url );
  374.             SSPush( st, value );
  375.             free( value );
  376.         }
  377.         else if( !strcmp( s, "addslashes" ) )
  378.         {
  379.             char *psz_src = SSPop( st );
  380.             char *psz_dest;
  381.             char *str = psz_src;
  383.             p = psz_dest = malloc( strlen( str ) * 2 + 1 );
  385.             while( *str != '' )
  386.             {
  387.                 if( *str == '"' || *str == ''' || *str == '\' )
  388.                 {
  389.                     *p++ = '\';
  390.                 }
  391.                 *p++ = *str;
  392.                 str++;
  393.             }
  394.             *p = '';
  396.             SSPush( st, psz_dest );
  397.             free( psz_src );
  398.             free( psz_dest );
  399.         }
  400.         else if( !strcmp( s, "stripslashes" ) )
  401.         {
  402.             char *psz_src = SSPop( st );
  403.             char *psz_dest;
  404.             char *str = psz_src;
  406.             p = psz_dest = strdup( psz_src );
  408.             while( *str )
  409.             {
  410.                 if( *str == '\' && *(str + 1) )
  411.                 {
  412.                     str++;
  413.                 }
  414.                 *p++ = *str++;
  415.             }
  416.             *p = '';
  418.             SSPush( st, psz_dest );
  419.             free( psz_src );
  420.             free( psz_dest );
  421.         }
  422.         else if( !strcmp( s, "realpath" ) )
  423.         {
  424.             char *psz_src = SSPop( st );
  425.             char *psz_dir = RealPath( psz_src );
  427.             SSPush( st, psz_dir );
  428.             free( psz_src );
  429.             free( psz_dir );
  430.         }
  431.         /* 4. stack functions */
  432.         else if( !strcmp( s, "dup" ) )
  433.         {
  434.             char *str = SSPop( st );
  435.             SSPush( st, str );
  436.             SSPush( st, str );
  437.             free( str );
  438.         }
  439.         else if( !strcmp( s, "drop" ) )
  440.         {
  441.             char *str = SSPop( st );
  442.             free( str );
  443.         }
  444.         else if( !strcmp( s, "swap" ) )
  445.         {
  446.             char *s1 = SSPop( st );
  447.             char *s2 = SSPop( st );
  449.             SSPush( st, s1 );
  450.             SSPush( st, s2 );
  451.             free( s1 );
  452.             free( s2 );
  453.         }
  454.         else if( !strcmp( s, "flush" ) )
  455.         {
  456.             SSClean( st );
  457.             SSInit( st );
  458.         }
  459.         else if( !strcmp( s, "store" ) )
  460.         {
  461.             char *value = SSPop( st );
  462.             char *name  = SSPop( st );
  464.             mvar_PushNewVar( vars, name, value );
  465.             free( name );
  466.             free( value );
  467.         }
  468.         else if( !strcmp( s, "value" ) )
  469.         {
  470.             char *name  = SSPop( st );
  471.             const char *value = mvar_GetValue( vars, name );
  473.             SSPush( st, value );
  475.             free( name );
  476.         }
  477.         /* 5. player control */
  478.         else if( !strcmp( s, "vlc_play" ) )
  479.         {
  480.             int i_id = SSPopN( st, vars );
  481.             int i_ret;
  483.             playlist_Lock( p_sys->p_playlist );
  484.             i_ret = playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
  485.                                       pl_Locked, NULL,
  486.                                       playlist_ItemGetById( p_sys->p_playlist,
  487.                                       i_id ) );
  488.             playlist_Unlock( p_sys->p_playlist );
  489.             msg_Dbg( p_intf, "requested playlist item: %i", i_id );
  490.             SSPushN( st, i_ret );
  491.         }
  492.         else if( !strcmp( s, "vlc_stop" ) )
  493.         {
  494.             playlist_Control( p_sys->p_playlist, PLAYLIST_STOP, pl_Unlocked );
  495.             msg_Dbg( p_intf, "requested playlist stop" );
  496.         }
  497.         else if( !strcmp( s, "vlc_pause" ) )
  498.         {
  499.             playlist_Control( p_sys->p_playlist, PLAYLIST_PAUSE, pl_Unlocked );
  500.             msg_Dbg( p_intf, "requested playlist pause" );
  501.         }
  502.         else if( !strcmp( s, "vlc_next" ) )
  503.         {
  504.             playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, 1 );
  505.             msg_Dbg( p_intf, "requested playlist next" );
  506.         }
  507.         else if( !strcmp( s, "vlc_previous" ) )
  508.         {
  509.             playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, -1 );
  510.             msg_Dbg( p_intf, "requested playlist previous" );
  511.         }
  512.         else if( !strcmp( s, "vlc_seek" ) )
  513.         {
  514.             char *psz_value = SSPop( st );
  515.             HandleSeek( p_intf, psz_value );
  516.             msg_Dbg( p_intf, "requested playlist seek: %s", psz_value );
  517.             free( psz_value );
  518.         }
  519.         else if( !strcmp( s, "vlc_var_type" )
  520.                   || !strcmp( s, "vlc_config_type" ) )
  521.         {
  522.             vlc_object_t *p_object;
  523.             const char *psz_type = NULL;
  524.             int i_type = 0;
  526.             if( !strcmp( s, "vlc_var_type" ) )
  527.             {
  528.                 char *psz_object = SSPop( st );
  529.                 char *psz_variable = SSPop( st );
  530.                 bool b_need_release;
  532.                 p_object = GetVLCObject( p_intf, psz_object, &b_need_release );
  534.                 if( p_object != NULL )
  535.                     i_type = var_Type( p_object, psz_variable );
  536.                 free( psz_variable );
  537.                 free( psz_object );
  538.                 if( b_need_release && p_object != NULL )
  539.                     vlc_object_release( p_object );
  540.             }
  541.             else
  542.             {
  543.                 char *psz_variable = SSPop( st );
  544.                 p_object = VLC_OBJECT(p_intf);
  545.                 i_type = config_GetType( p_object, psz_variable );
  546.                 free( psz_variable );
  547.             }
  549.             if( p_object != NULL )
  550.             {
  551.                 switch( i_type & VLC_VAR_TYPE )
  552.                 {
  553.                 case VLC_VAR_BOOL:
  554.                     psz_type = "VLC_VAR_BOOL";
  555.                     break;
  556.                 case VLC_VAR_INTEGER:
  557.                     psz_type = "VLC_VAR_INTEGER";
  558.                     break;
  559.                 case VLC_VAR_HOTKEY:
  560.                     psz_type = "VLC_VAR_HOTKEY";
  561.                     break;
  562.                 case VLC_VAR_STRING:
  563.                     psz_type = "VLC_VAR_STRING";
  564.                     break;
  565.                 case VLC_VAR_MODULE:
  566.                     psz_type = "VLC_VAR_MODULE";
  567.                     break;
  568.                 case VLC_VAR_FILE:
  569.                     psz_type = "VLC_VAR_FILE";
  570.                     break;
  571.                 case VLC_VAR_DIRECTORY:
  572.                     psz_type = "VLC_VAR_DIRECTORY";
  573.                     break;
  574.                 case VLC_VAR_VARIABLE:
  575.                     psz_type = "VLC_VAR_VARIABLE";
  576.                     break;
  577.                 case VLC_VAR_FLOAT:
  578.                     psz_type = "VLC_VAR_FLOAT";
  579.                     break;
  580.                 default:
  581.                     psz_type = "UNDEFINED";
  582.                 }
  583.             }
  584.             else
  585.                 psz_type = "INVALID";
  587.             SSPush( st, psz_type );
  588.         }
  589.         else if( !strcmp( s, "vlc_var_set" ) )
  590.         {
  591.             char *psz_object = SSPop( st );
  592.             char *psz_variable = SSPop( st );
  593.             bool b_need_release;
  595.             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
  596.                                                    &b_need_release );
  598.             if( p_object != NULL )
  599.             {
  600.                 bool b_error = false;
  601.                 char *psz_value = NULL;
  602.                 vlc_value_t val;
  603.                 int i_type;
  605.                 i_type = var_Type( p_object, psz_variable );
  607.                 switch( i_type & VLC_VAR_TYPE )
  608.                 {
  609.                 case VLC_VAR_BOOL:
  610.                     val.b_bool = SSPopN( st, vars );
  611.                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
  612.                              psz_object, psz_variable, val.b_bool );
  613.                     break;
  614.                 case VLC_VAR_INTEGER:
  615.                 case VLC_VAR_HOTKEY:
  616.                     val.i_int = SSPopN( st, vars );
  617.                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
  618.                              psz_object, psz_variable, val.i_int );
  619.                     break;
  620.                 case VLC_VAR_STRING:
  621.                 case VLC_VAR_MODULE:
  622.                 case VLC_VAR_FILE:
  623.                 case VLC_VAR_DIRECTORY:
  624.                 case VLC_VAR_VARIABLE:
  625.                     val.psz_string = psz_value = SSPop( st );
  626.                     msg_Dbg( p_intf, "requested %s var change: %s->%s",
  627.                              psz_object, psz_variable, psz_value );
  628.                     break;
  629.                 case VLC_VAR_FLOAT:
  630.                     psz_value = SSPop( st );
  631.                     val.f_float = atof( psz_value );
  632.                     msg_Dbg( p_intf, "requested %s var change: %s->%f",
  633.                              psz_object, psz_variable, val.f_float );
  634.                     break;
  635.                 default:
  636.                     SSPopN( st, vars );
  637.                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
  638.                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
  639.                     b_error = true;
  640.                 }
  642.                 if( !b_error )
  643.                     var_Set( p_object, psz_variable, val );
  644.                 if( psz_value != NULL )
  645.                     free( psz_value );
  646.             }
  647.             else
  648.                 msg_Warn( p_intf, "vlc_var_set called without an object" );
  649.             free( psz_variable );
  650.             free( psz_object );
  652.             if( b_need_release && p_object != NULL )
  653.                 vlc_object_release( p_object );
  654.         }
  655.         else if( !strcmp( s, "vlc_var_get" ) )
  656.         {
  657.             char *psz_object = SSPop( st );
  658.             char *psz_variable = SSPop( st );
  659.             bool b_need_release;
  661.             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
  662.                                                    &b_need_release );
  664.             if( p_object != NULL )
  665.             {
  666.                 vlc_value_t val;
  667.                 int i_type;
  669.                 i_type = var_Type( p_object, psz_variable );
  670.                 var_Get( p_object, psz_variable, &val );
  672.                 switch( i_type & VLC_VAR_TYPE )
  673.                 {
  674.                 case VLC_VAR_BOOL:
  675.                     SSPushN( st, val.b_bool );
  676.                     break;
  677.                 case VLC_VAR_INTEGER:
  678.                 case VLC_VAR_HOTKEY:
  679.                     SSPushN( st, val.i_int );
  680.                     break;
  681.                 case VLC_VAR_STRING:
  682.                 case VLC_VAR_MODULE:
  683.                 case VLC_VAR_FILE:
  684.                 case VLC_VAR_DIRECTORY:
  685.                 case VLC_VAR_VARIABLE:
  686.                     SSPush( st, val.psz_string );
  687.                     free( val.psz_string );
  688.                     break;
  689.                 case VLC_VAR_FLOAT:
  690.                 {
  691.                     char psz_value[20];
  692.                     lldiv_t value = lldiv( val.f_float * 1000000, 1000000 );
  693.                     snprintf( psz_value, sizeof(psz_value), "%lld.%06u",
  694.                                     value.quot, (unsigned int)value.rem );
  695.                     SSPush( st, psz_value );
  696.                     break;
  697.                 }
  698.                 default:
  699.                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
  700.                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
  701.                     SSPush( st, "" );
  702.                 }
  703.             }
  704.             else
  705.             {
  706.                 msg_Warn( p_intf, "vlc_var_get called without an object" );
  707.                 SSPush( st, "" );
  708.             }
  709.             free( psz_variable );
  710.             free( psz_object );
  712.             if( b_need_release && p_object != NULL )
  713.                 vlc_object_release( p_object );
  714.         }
  715.         else if( !strcmp( s, "vlc_object_exists" ) )
  716.         {
  717.             char *psz_object = SSPop( st );
  718.             bool b_need_release;
  720.             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
  721.                                                    &b_need_release );
  722.             if( b_need_release && p_object != NULL )
  723.                 vlc_object_release( p_object );
  725.             if( p_object != NULL )
  726.                 SSPush( st, "1" );
  727.             else
  728.                 SSPush( st, "0" );
  729.         }
  730.         else if( !strcmp( s, "vlc_config_set" ) )
  731.         {
  732.             char *psz_variable = SSPop( st );
  733.             int i_type = config_GetType( p_intf, psz_variable );
  735.             switch( i_type & VLC_VAR_TYPE )
  736.             {
  737.             case VLC_VAR_BOOL:
  738.             case VLC_VAR_INTEGER:
  739.                 config_PutInt( p_intf, psz_variable, SSPopN( st, vars ) );
  740.                 break;
  741.             case VLC_VAR_STRING:
  742.             case VLC_VAR_MODULE:
  743.             case VLC_VAR_FILE:
  744.             case VLC_VAR_DIRECTORY:
  745.             {
  746.                 char *psz_string = SSPop( st );
  747.                 config_PutPsz( p_intf, psz_variable, psz_string );
  748.                 free( psz_string );
  749.                 break;
  750.             }
  751.             case VLC_VAR_FLOAT:
  752.             {
  753.                 char *psz_string = SSPop( st );
  754.                 config_PutFloat( p_intf, psz_variable, atof(psz_string) );
  755.                 free( psz_string );
  756.                 break;
  757.             }
  758.             default:
  759.                 msg_Warn( p_intf, "vlc_config_set called on unknown var (%s)",
  760.                           psz_variable );
  761.             }
  762.             free( psz_variable );
  763.         }
  764.         else if( !strcmp( s, "vlc_config_get" ) )
  765.         {
  766.             char *psz_variable = SSPop( st );
  767.             int i_type = config_GetType( p_intf, psz_variable );
  769.             switch( i_type & VLC_VAR_TYPE )
  770.             {
  771.             case VLC_VAR_BOOL:
  772.             case VLC_VAR_INTEGER:
  773.                 SSPushN( st, config_GetInt( p_intf, psz_variable ) );
  774.                 break;
  775.             case VLC_VAR_STRING:
  776.             case VLC_VAR_MODULE:
  777.             case VLC_VAR_FILE:
  778.             case VLC_VAR_DIRECTORY:
  779.             {
  780.                 char *psz_string = config_GetPsz( p_intf, psz_variable );
  781.                 SSPush( st, psz_string );
  782.                 free( psz_string );
  783.                 break;
  784.             }
  785.             case VLC_VAR_FLOAT:
  786.             {
  787.                 char psz_string[20];
  788.                 lldiv_t value = lldiv( config_GetFloat( p_intf, psz_variable )
  789.                                        * 1000000, 1000000 );
  790.                 snprintf( psz_string, sizeof(psz_string), "%lld.%06u",
  791.                           value.quot, (unsigned int)value.rem );
  792.                 SSPush( st, psz_string );
  793.                 break;
  794.             }
  795.             default:
  796.                 msg_Warn( p_intf, "vlc_config_get called on unknown var (%s)",
  797.                           psz_variable );
  798.                 SSPush( st, "" );
  799.             }
  800.             free( psz_variable );
  801.         }
  802.         else if( !strcmp( s, "vlc_config_save" ) )
  803.         {
  804.             char *psz_module = SSPop( st );
  805.             int i_result;
  807.             if( !*psz_module )
  808.             {
  809.                 free( psz_module );
  810.                 psz_module = NULL;
  811.             }
  812.             i_result = config_SaveConfigFile( p_intf, psz_module );
  814.             if( psz_module != NULL )
  815.                 free( psz_module );
  816.             SSPushN( st, i_result );
  817.         }
  818.         else if( !strcmp( s, "vlc_config_reset" ) )
  819.         {
  820.             config_ResetAll( p_intf );
  821.         }
  822.         /* 6. playlist functions */
  823.         else if( !strcmp( s, "playlist_add" ) )
  824.         {
  825.             char *psz_name = SSPop( st );
  826.             char *mrl = SSPop( st );
  827.             input_item_t *p_input;
  828.             int i_ret;
  830.             p_input = MRLParse( p_intf, mrl, psz_name );
  832.             char *psz_uri = input_item_GetURI( p_input );
  833.             if( !p_input || !psz_uri || !*psz_uri )
  834.             {
  835.                 i_ret = VLC_EGENERIC;
  836.                 msg_Dbg( p_intf, "invalid requested mrl: %s", mrl );
  837.             }
  838.             else
  839.             {
  840.                 i_ret = playlist_AddInput( p_sys->p_playlist, p_input,
  841.                                    PLAYLIST_APPEND, PLAYLIST_END, true,
  842.                                    pl_Unlocked );
  843.                 if( i_ret == VLC_SUCCESS )
  844.                 {
  845.                     playlist_item_t *p_item;
  846.                     msg_Dbg( p_intf, "requested mrl add: %s", mrl );
  847.                     playlist_Lock( p_sys->p_playlist );
  848.                     p_item = playlist_ItemGetByInput( p_sys->p_playlist,
  849.                                                       p_input );
  850.                     if( p_item )
  851.                         i_ret = p_item->i_id;
  852.                     playlist_Unlock( p_sys->p_playlist );
  853.                 }
  854.                 else
  855.                     msg_Warn( p_intf, "adding mrl %s failed", mrl );
  856.                 vlc_gc_decref( p_input );
  857.             }
  858.             free( psz_uri );
  859.             SSPushN( st, i_ret );
  861.             free( mrl );
  862.             free( psz_name );
  863.         }
  864.         else if( !strcmp( s, "playlist_empty" ) )
  865.         {
  866.             playlist_Clear( p_sys->p_playlist, pl_Unlocked );
  867.             msg_Dbg( p_intf, "requested playlist empty" );
  868.         }
  869.         else if( !strcmp( s, "playlist_delete" ) )
  870.         {
  871.             int i_id = SSPopN( st, vars );
  872.             playlist_Lock( p_sys->p_playlist );
  873.             playlist_item_t *p_item = playlist_ItemGetById( p_sys->p_playlist,
  874.                                                             i_id );
  875.             if( p_item )
  876.             {
  877.                 playlist_DeleteFromInput( p_sys->p_playlist,
  878.                                           p_item->p_input->i_id, pl_Locked );
  879.                 msg_Dbg( p_intf, "requested playlist delete: %d", i_id );
  880.             }
  881.             else
  882.             {
  883.                 msg_Dbg( p_intf, "couldn't find playlist item to delete (%d)",
  884.                          i_id );
  885.             }
  886.             playlist_Unlock( p_sys->p_playlist );
  887.         }
  888.         else if( !strcmp( s, "playlist_move" ) )
  889.         {
  890.             /*int i_newpos =*/ SSPopN( st, vars );
  891.             /*int i_pos =*/ SSPopN( st, vars );
  892.             /* FIXME FIXME TODO TODO XXX XXX
  893.             do not release before fixing this
  894.             if ( i_pos < i_newpos )
  895.             {
  896.                 playlist_Move( p_sys->p_playlist, i_pos, i_newpos + 1 );
  897.             }
  898.             else
  899.             {
  900.                 playlist_Move( p_sys->p_playlist, i_pos, i_newpos );
  901.             }
  902.             msg_Dbg( p_intf, "requested to move playlist item %d to %d",
  903.                      i_pos, i_newpos);
  904.                FIXME FIXME TODO TODO XXX XXX */
  905.             msg_Err( p_intf, "moving using indexes is obsolete. We need to update this function" );
  906.         }
  907.         else if( !strcmp( s, "playlist_sort" ) )
  908.         {
  909.             int i_order = SSPopN( st, vars );
  910.             int i_sort = SSPopN( st, vars );
  911.             i_order = i_order % 2;
  912.             i_sort = i_sort % 9;
  913.             /* FIXME FIXME TODO TODO XXX XXX
  914.             do not release before fixing this
  915.             playlist_RecursiveNodeSort(  p_sys->p_playlist,
  916.                                          p_sys->p_playlist->p_general,
  917.                                          i_sort, i_order );
  918.             msg_Dbg( p_intf, "requested sort playlist by : %d in order : %d",
  919.                      i_sort, i_order );
  920.                FIXME FIXME TODO TODO XXX XXX */
  921.             msg_Err( p_intf, "this needs to be fixed to use the new playlist framework" );
  922.         }
  923.         else if( !strcmp( s, "services_discovery_add" ) )
  924.         {
  925.             char *psz_sd = SSPop( st );
  926.             playlist_ServicesDiscoveryAdd( p_sys->p_playlist, psz_sd );
  927.             free( psz_sd );
  928.         }
  929.         else if( !strcmp( s, "services_discovery_remove" ) )
  930.         {
  931.             char *psz_sd = SSPop( st );
  932.             playlist_ServicesDiscoveryRemove( p_sys->p_playlist, psz_sd );
  933.             free( psz_sd );
  934.         }
  935.         else if( !strcmp( s, "services_discovery_is_loaded" ) )
  936.         {
  937.             char *psz_sd = SSPop( st );
  938.             SSPushN( st,
  939.             playlist_IsServicesDiscoveryLoaded( p_sys->p_playlist, psz_sd ) );
  940.             free( psz_sd );
  941.         }
  942.         else if( !strcmp( s, "vlc_volume_set" ) )
  943.         {
  944.             char *psz_vol = SSPop( st );
  945.             int i_value;
  946.             audio_volume_t i_volume;
  947.             aout_VolumeGet( p_intf, &i_volume );
  948.             if( psz_vol[0] == '+' )
  949.             {
  950.                 i_value = atoi( psz_vol );
  951.                 if( (i_volume + i_value) > AOUT_VOLUME_MAX )
  952.                     aout_VolumeSet( p_intf, AOUT_VOLUME_MAX );
  953.                 else
  954.                     aout_VolumeSet( p_intf, i_volume + i_value );
  955.             }
  956.             else if( psz_vol[0] == '-' )
  957.             {
  958.                 i_value = atoi( psz_vol );
  959.                 if( (i_volume + i_value) < AOUT_VOLUME_MIN )
  960.                     aout_VolumeSet( p_intf, AOUT_VOLUME_MIN );
  961.                 else
  962.                     aout_VolumeSet( p_intf, i_volume + i_value );
  963.             }
  964.             else if( strstr( psz_vol, "%") != NULL )
  965.             {
  966.                 i_value = atoi( psz_vol );
  967.                 if( i_value < 0 ) i_value = 0;
  968.                 if( i_value > 400 ) i_value = 400;
  969.                 aout_VolumeSet( p_intf, (i_value * (AOUT_VOLUME_MAX - AOUT_VOLUME_MIN))/400+AOUT_VOLUME_MIN);
  970.             }
  971.             else
  972.             {
  973.                 i_value = atoi( psz_vol );
  974.                 if( i_value > AOUT_VOLUME_MAX ) i_value = AOUT_VOLUME_MAX;
  975.                 if( i_value < AOUT_VOLUME_MIN ) i_value = AOUT_VOLUME_MIN;
  976.                 aout_VolumeSet( p_intf, i_value );
  977.             }
  978.             aout_VolumeGet( p_intf, &i_volume );
  979.             free( psz_vol );
  980.         }
  981.         else if( !strcmp( s, "vlc_get_meta" ) )
  982.         {
  983.             char *psz_meta = SSPop( st );
  984.             char *psz_val = NULL;
  985.             if( p_sys->p_input && input_GetItem(p_sys->p_input) )
  986.             {
  987. #define p_item input_GetItem( p_sys->p_input )
  988.                 if( !strcmp( psz_meta, "ARTIST" ) )
  989.                 {
  990.                     psz_val = input_item_GetArtist( p_item );
  991.                 }
  992.                 else if( !strcmp( psz_meta, "TITLE" ) )
  993.                 {
  994.                     psz_val = input_item_GetTitle( p_item );
  995.                     if( !psz_val )
  996.                         psz_val = input_item_GetName( p_item );
  997.                 }
  998.                 else if( !strcmp( psz_meta, "ALBUM" ) )
  999.                 {
  1000.                     psz_val = input_item_GetAlbum( p_item );
  1001.                 }
  1002.                 else if( !strcmp( psz_meta, "GENRE" ) )
  1003.                 {
  1004.                     psz_val = input_item_GetGenre( p_item );
  1005.                 }
  1006.                 else if( !strcmp( psz_meta, "COPYRIGHT" ) )
  1007.                 {
  1008.                      psz_val = input_item_GetCopyright( p_item );
  1009.                 }
  1010.                 else if( !strcmp( psz_meta, "TRACK_NUMBER" ) )
  1011.                 {
  1012.                     psz_val = input_item_GetTrackNum( p_item );
  1013.                 }
  1014.                 else if( !strcmp( psz_meta, "DESCRIPTION" ) )
  1015.                 {
  1016.                     psz_val = input_item_GetDescription( p_item );
  1017.                 }
  1018.                 else if( !strcmp( psz_meta, "RATING" ) )
  1019.                 {
  1020.                     psz_val = input_item_GetRating( p_item );
  1021.                 }
  1022.                 else if( !strcmp( psz_meta, "DATE" ) )
  1023.                 {
  1024.                     psz_val = input_item_GetDate( p_item );
  1025.                 }
  1026.                 else if( !strcmp( psz_meta, "URL" ) )
  1027.                 {
  1028.                     psz_val = input_item_GetURL( p_item );
  1029.                 }
  1030.                 else if( !strcmp( psz_meta, "LANGUAGE" ) )
  1031.                 {
  1032.                     psz_val = input_item_GetLanguage( p_item );
  1033.                 }
  1034.                 else if( !strcmp( psz_meta, "NOW_PLAYING" ) )
  1035.                 {
  1036.                     psz_val = input_item_GetNowPlaying( p_item );
  1037.                 }
  1038.                 else if( !strcmp( psz_meta, "PUBLISHER" ) )
  1039.                 {
  1040.                     psz_val = input_item_GetPublisher( p_item );
  1041.                 }
  1042.                 else if( !strcmp( psz_meta, "ENCODED_BY" ) )
  1043.                 {
  1044.                     psz_val = input_item_GetEncodedBy( p_item );
  1045.                 }
  1046.                 else if( !strcmp( psz_meta, "ART_URL" ) )
  1047.                 {
  1048.                     psz_val = input_item_GetEncodedBy( p_item );
  1049.                 }
  1050.                 else if( !strcmp( psz_meta, "TRACK_ID" ) )
  1051.                 {
  1052.                     psz_val = input_item_GetTrackID( p_item );
  1053.                 }
  1054. #undef p_item
  1055.             }
  1056.             if( psz_val == NULL ) psz_val = strdup( "" );
  1057.             SSPush( st, psz_val );
  1058.             free( psz_meta );
  1059.             free( psz_val );
  1060.         }
  1061. #ifdef ENABLE_VLM
  1062.         else if( !strcmp( s, "vlm_command" ) || !strcmp( s, "vlm_cmd" ) )
  1063.         {
  1064.             char *psz_elt;
  1065.             char *psz_cmd = strdup( "" );
  1066.             char *psz_error;
  1067.             vlm_message_t *vlm_answer;
  1069.             /* make sure that we have a vlm object */
  1070.             if( p_intf->p_sys->p_vlm == NULL )
  1071.                 p_intf->p_sys->p_vlm = vlm_New( p_intf );
  1074.             /* vlm command uses the ';' delimiter
  1075.              * (else we can't know when to stop) */
  1076.             while( strcmp( psz_elt = SSPop( st ), "" )
  1077.                    && strcmp( psz_elt, ";" ) )
  1078.             {
  1079.                 char* psz_buf;
  1080.                 if( asprintf( &psz_buf, "%s %s", psz_cmd, psz_elt ) == -1 )
  1081.                     psz_buf = NULL;
  1082.                 free( psz_cmd );
  1083.                 free( psz_elt );
  1084.                 psz_cmd = psz_buf;
  1085.             }
  1087.             msg_Dbg( p_intf, "executing vlm command: %s", psz_cmd );
  1088.             vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz_cmd, &vlm_answer );
  1090.             if( vlm_answer->psz_value == NULL )
  1091.             {
  1092.                 psz_error = strdup( "" );
  1093.             }
  1094.             else
  1095.             {
  1096.                 if( asprintf( &psz_error , "%s : %s" , vlm_answer->psz_name,
  1097.                               vlm_answer->psz_value ) == -1 )
  1098.                     psz_error = NULL;
  1099.             }
  1101.             mvar_AppendNewVar( vars, "vlm_error", psz_error );
  1102.             /* this is kind of a duplicate but we need to have the message
  1103.              * without the command name for the "export" command */
  1104.             mvar_AppendNewVar( vars, "vlm_value", vlm_answer->psz_value );
  1105.             vlm_MessageDelete( vlm_answer );
  1107.             free( psz_cmd );
  1108.             free( psz_error );
  1109.         }
  1110. #endif /* ENABLE_VLM */
  1111.         else if( !strcmp( s, "snapshot" ) )
  1112.         {
  1113.             if( p_sys->p_input )
  1114.             {
  1115.                 vout_thread_t *p_vout = input_GetVout( p_sys->p_input );
  1116.                 if( p_vout )
  1117.                 {
  1118.                     var_TriggerCallback( p_vout, "video-snapshot" );
  1119.                     vlc_object_release( p_vout );
  1120.                     msg_Dbg( p_intf, "requested snapshot" );
  1121.                 }
  1122.             }
  1123.             break;
  1125.         }
  1126.         else
  1127.         {
  1128.             SSPush( st, s );
  1129.         }
  1130.     }
  1131. }