macro.c

uclinux 下的vlc播放器源代码

                default:
                    snprintf( value, sizeof( value ),
                              "invalid type(%s) in set", m->param2 );
                    break;
            }
            PRINTS( "%s", value );
            break;
        }
        case MVLC_VALUE:
        {
            char *s, *v;

            if( m->param1 )
            {
                E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m->param1 );
                s = E_(SSPop)( &p_args->stack );
                v = E_(mvar_GetValue)( p_args->vars, s );
            }
            else
            {
                v = s = E_(SSPop)( &p_args->stack );
            }

            PRINTS( "%s", v );
            free( s );
            break;
        }
        case MVLC_RPN:
            E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m->param1 );
            break;

        /* Useful to learn stack management */
        case MVLC_STACK:
        {
            int i;
            msg_Dbg( p_intf, "stack" );
            for (i=0;i<(&p_args->stack)->i_stack;i++)
                msg_Dbg( p_intf, "%d -> %s", i, (&p_args->stack)->stack[i] );
            break;
        }

        case MVLC_UNKNOWN:
        default:
            PRINTS( "<!-- invalid macro id=`%s' -->", m->id );
            msg_Dbg( p_intf, "invalid macro id=`%s'", m->id );
            break;
    }
#undef PRINTS
#undef PRINT
#undef ALLOC
}

char *E_(MacroSearch)( char *src, char *end, int i_mvlc, vlc_bool_t b_after )
{
    int     i_id;
    int     i_level = 0;

    while( src < end )
    {
        if( src + 4 < end  && !strncmp( (char *)src, "<vlc", 4 ) )
        {
            int i_skip;
            macro_t m;

            i_skip = E_(MacroParse)( &m, src );

            i_id = E_(StrToMacroType)( m.id );

            switch( i_id )
            {
                case MVLC_IF:
                case MVLC_FOREACH:
                    i_level++;
                    break;
                case MVLC_END:
                    i_level--;
                    break;
                default:
                    break;
            }

            E_(MacroClean)( &m );

            if( ( i_mvlc == MVLC_END && i_level == -1 ) ||
                ( i_mvlc != MVLC_END && i_level == 0 && i_mvlc == i_id ) )
            {
                return src + ( b_after ? i_skip : 0 );
            }
            else if( i_level < 0 )
            {
                return NULL;
            }

            src += i_skip;
        }
        else
        {
            src++;
        }
    }

    return NULL;
}

void E_(Execute)( httpd_file_sys_t *p_args,
                     char *p_request, int i_request,
                     char **pp_data, int *pi_data,
                     char **pp_dst,
                     char *_src, char *_end )
{
    intf_thread_t  *p_intf = p_args->p_intf;

    char *src, *dup, *end;
    char *dst = *pp_dst;

    src = dup = malloc( _end - _src + 1 );
    end = src +( _end - _src );

    memcpy( src, _src, _end - _src );
    *end = '\0';

    /* we parse searching <vlc */
    while( src < end )
    {
        char *p;
        int i_copy;

        p = (char *)strstr( (char *)src, "<vlc" );
        if( p < end && p == src )
        {
            macro_t m;

            src += E_(MacroParse)( &m, src );

            //msg_Dbg( p_intf, "macro_id=%s", m.id );

            switch( E_(StrToMacroType)( m.id ) )
            {
                case MVLC_INCLUDE:
                {
                    FILE *f;
                    int  i_buffer;
                    char *p_buffer;
                    char psz_file[MAX_DIR_SIZE];
                    char *p;
                    char sep;

#if defined( WIN32 )
                    sep = '\\';
#else
                    sep = '/';
#endif

                    if( m.param1[0] != sep )
                    {
                        strcpy( psz_file, p_args->file );
                        p = strrchr( psz_file, sep );
                        if( p != NULL )
                            strcpy( p + 1, m.param1 );
                        else
                            strcpy( psz_file, m.param1 );
                    }
                    else
                    {
                        strcpy( psz_file, m.param1 );
                    }

                    /* We hereby assume that psz_file is in the
                     * local character encoding */
                    if( ( f = fopen( psz_file, "r" ) ) == NULL )
                    {
                        msg_Warn( p_args->p_intf,
                                  "unable to include file %s (%s)",
                                  psz_file, strerror(errno) );
                        break;
                    }

                    /* first we load in a temporary buffer */
                    E_(FileLoad)( f, &p_buffer, &i_buffer );

                    /* we parse executing all  <vlc /> macros */
                    E_(Execute)( p_args, p_request, i_request, pp_data, pi_data,
                             &dst, &p_buffer[0], &p_buffer[i_buffer] );
                    free( p_buffer );
                    fclose(f);
                    break;
                }
                case MVLC_IF:
                {
                    vlc_bool_t i_test;
                    char    *endif;

                    E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m.param1 );
                    if( E_(SSPopN)( &p_args->stack, p_args->vars ) )
                    {
                        i_test = 1;
                    }
                    else
                    {
                        i_test = 0;
                    }
                    endif = E_(MacroSearch)( src, end, MVLC_END, VLC_TRUE );

                    if( i_test == 0 )
                    {
                        char *start = E_(MacroSearch)( src, endif, MVLC_ELSE, VLC_TRUE );

                        if( start )
                        {
                            char *stop  = E_(MacroSearch)( start, endif, MVLC_END, VLC_FALSE );
                            if( stop )
                            {
                                E_(Execute)( p_args, p_request, i_request,
                                         pp_data, pi_data, &dst, start, stop );
                            }
                        }
                    }
                    else if( i_test == 1 )
                    {
                        char *stop;
                        if( ( stop = E_(MacroSearch)( src, endif, MVLC_ELSE, VLC_FALSE ) ) == NULL )
                        {
                            stop = E_(MacroSearch)( src, endif, MVLC_END, VLC_FALSE );
                        }
                        if( stop )
                        {
                            E_(Execute)( p_args, p_request, i_request,
                                     pp_data, pi_data, &dst, src, stop );
                        }
                    }

                    src = endif;
                    break;
                }
                case MVLC_FOREACH:
                {
                    char *endfor = E_(MacroSearch)( src, end, MVLC_END, VLC_TRUE );
                    char *start = src;
                    char *stop = E_(MacroSearch)( src, end, MVLC_END, VLC_FALSE );

                    if( stop )
                    {
                        mvar_t *index;
                        int    i_idx;
                        mvar_t *v;
                        if( !strcmp( m.param2, "integer" ) )
                        {
                            char *arg = E_(SSPop)( &p_args->stack );
                            index = E_(mvar_IntegerSetNew)( m.param1, arg );
                            free( arg );
                        }
                        else if( !strcmp( m.param2, "directory" ) )
                        {
                            char *arg = E_(SSPop)( &p_args->stack );
                            index = E_(mvar_FileSetNew)( p_intf, m.param1, arg );
                            free( arg );
                        }
                        else if( !strcmp( m.param2, "object" ) )
                        {
                            char *arg = E_(SSPop)( &p_args->stack );
                            index = E_(mvar_ObjectSetNew)( p_intf, m.param1, arg );
                            free( arg );
                        }
                        else if( !strcmp( m.param2, "playlist" ) )
                        {
                            index = E_(mvar_PlaylistSetNew)( p_intf, m.param1,
                                                    p_intf->p_sys->p_playlist );
                        }
                        else if( !strcmp( m.param2, "information" ) )
                        {
                            index = E_(mvar_InfoSetNew)( p_intf, m.param1,
                                                     p_intf->p_sys->p_input );
                        }
                        else if( !strcmp( m.param2, "program" )
                                  || !strcmp( m.param2, "title" )
                                  || !strcmp( m.param2, "chapter" )
                                  || !strcmp( m.param2, "audio-es" )
                                  || !strcmp( m.param2, "video-es" )
                                  || !strcmp( m.param2, "spu-es" ) )
                        {
                            index = E_(mvar_InputVarSetNew)( p_intf, m.param1,
                                                         p_intf->p_sys->p_input,
                                                         m.param2 );
                        }
                        else if( !strcmp( m.param2, "vlm" ) )
                        {
                            if( p_intf->p_sys->p_vlm == NULL )
                                p_intf->p_sys->p_vlm = vlm_New( p_intf );
                            index = E_(mvar_VlmSetNew)( m.param1, p_intf->p_sys->p_vlm );
                        }
#if 0
                        else if( !strcmp( m.param2, "hosts" ) )
                        {
                            index = E_(mvar_HttpdInfoSetNew)( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_HOSTS );
                        }
                        else if( !strcmp( m.param2, "urls" ) )
                        {
                            index = E_(mvar_HttpdInfoSetNew)( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_URLS );
                        }
                        else if( !strcmp( m.param2, "connections" ) )
                        {
                            index = E_(mvar_HttpdInfoSetNew)(m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_CONNECTIONS);
                        }
#endif
                        else if( ( v = E_(mvar_GetVar)( p_args->vars, m.param2 ) ) )
                        {
                            index = E_(mvar_Duplicate)( v );
                        }
                        else
                        {
                            msg_Dbg( p_intf, "invalid index constructor (%s)", m.param2 );
                            src = endfor;
                            break;
                        }

                        for( i_idx = 0; i_idx < index->i_field; i_idx++ )
                        {
                            mvar_t *f = E_(mvar_Duplicate)( index->field[i_idx] );

                            //msg_Dbg( p_intf, "foreach field[%d] name=%s value=%s", i_idx, f->name, f->value );

                            free( f->name );
                            f->name = strdup( m.param1 );


                            E_(mvar_PushVar)( p_args->vars, f );
                            E_(Execute)( p_args, p_request, i_request,
                                     pp_data, pi_data, &dst, start, stop );
                            E_(mvar_RemoveVar)( p_args->vars, f );

                            E_(mvar_Delete)( f );
                        }
                        E_(mvar_Delete)( index );

                        src = endfor;
                    }
                    break;
                }
                default:
                    E_(MacroDo)( p_args, &m, p_request, i_request,
                                 pp_data, pi_data, &dst );
                    break;
            }

            E_(MacroClean)( &m );
            continue;
        }

        i_copy =   ( (p == NULL || p > end ) ? end : p  ) - src;
        if( i_copy > 0 )
        {
            int i_index = dst - *pp_data;

            *pi_data += i_copy;
            *pp_data = realloc( *pp_data, *pi_data );
            dst = (*pp_data) + i_index;

            memcpy( dst, src, i_copy );
            dst += i_copy;
            src += i_copy;
        }
    }

    *pp_dst = dst;
    free( dup );
}