Software: Apache. PHP/5.4.45 

uname -a: Linux webm003.cluster110.gra.hosting.ovh.net 5.15.167-ovh-vps-grsec-zfs-classid #1 SMP Tue
Sep 17 08:14:20 UTC 2024 x86_64
 

uid=243112(mycochar) gid=100(users) groups=100(users)  

Safe-mode: OFF (not secure)

/home/mycochar/Python-3.10.12/Tools/c-analyzer/c_parser/   drwxr-xr-x
Free 0 B of 0 B (0%)
Your ip: 216.73.216.218 - Server ip: 213.186.33.19
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    

[Enumerate]    [Encoder]    [Tools]    [Proc.]    [FTP Brute]    [Sec.]    [SQL]    [PHP-Code]    [Backdoor Host]    [Back-Connection]    [milw0rm it!]    [PHP-Proxy]    [Self remove]
    


Viewing file:     _state_machine.py (6.52 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |

f'''
    struct {ANON_IDENTIFIER};
    struct {{ ... }}
    struct {IDENTIFIER} {{ ... }}

    union {ANON_IDENTIFIER};
    union {{ ... }}
    union {IDENTIFIER} {{ ... }}

    enum {ANON_IDENTIFIER};
    enum {{ ... }}
    enum {IDENTIFIER} {{ ... }}

    typedef {VARTYPE} {IDENTIFIER};
    typedef {IDENTIFIER};
    typedef {IDENTIFIER};
    typedef {IDENTIFIER};
'''


def parse(srclines):
    if isinstance(srclines, str):  # a filename
        raise NotImplementedError



# This only handles at most 10 nested levels.
#MATCHED_PARENS = textwrap.dedent(rf'''
#    # matched parens
#    (?:
#        [(]  # level 0
#        (?:
#            [^()]*
#            [(]  # level 1
#            (?:
#                [^()]*
#                [(]  # level 2
#                (?:
#                    [^()]*
#                    [(]  # level 3
#                    (?:
#                        [^()]*
#                        [(]  # level 4
#                        (?:
#                            [^()]*
#                            [(]  # level 5
#                            (?:
#                                [^()]*
#                                [(]  # level 6
#                                (?:
#                                    [^()]*
#                                    [(]  # level 7
#                                    (?:
#                                        [^()]*
#                                        [(]  # level 8
#                                        (?:
#                                            [^()]*
#                                            [(]  # level 9
#                                            (?:
#                                                [^()]*
#                                                [(]  # level 10
#                                                [^()]*
#                                                [)]
#                                             )*
#                                            [^()]*
#                                            [)]
#                                         )*
#                                        [^()]*
#                                        [)]
#                                     )*
#                                    [^()]*
#                                    [)]
#                                 )*
#                                [^()]*
#                                [)]
#                             )*
#                            [^()]*
#                            [)]
#                         )*
#                        [^()]*
#                        [)]
#                     )*
#                    [^()]*
#                    [)]
#                 )*
#                [^()]*
#                [)]
#             )*
#            [^()]*
#            [)]
#         )*
#        [^()]*
#        [)]
#     )
#    # end matched parens
#    ''')

'''
        # for loop
        (?:
            \s* \b for
            \s* [(]
            (
                [^;]* ;
                [^;]* ;
                .*?
             )  # <header>
            [)]
            \s*
            (?:
                (?:
                    (
                        {_ind(SIMPLE_STMT, 6)}
                     )  # <stmt>
                    ;
                 )
                |
                ( {{ )  # <open>
             )
         )
        |



            (
                (?:
                    (?:
                        (?:
                            {_ind(SIMPLE_STMT, 6)}
                         )?
                        return \b \s*
                        {_ind(INITIALIZER, 5)}
                     )
                    |
                    (?:
                        (?:
                            {IDENTIFIER} \s*
                            (?: . | -> ) \s*
                         )*
                        {IDENTIFIER}
                        \s* = \s*
                        {_ind(INITIALIZER, 5)}
                     )
                    |
                    (?:
                        {_ind(SIMPLE_STMT, 5)}
                     )
                 )
                |
                # cast compound literal
                (?:
                    (?:
                        [^'"{{}};]*
                        {_ind(STRING_LITERAL, 5)}
                     )*
                    [^'"{{}};]*?
                    [^'"{{}};=]
                    =
                    \s* [(] [^)]* [)]
                    \s* {{ [^;]* }}
                 )
             )  # <stmt>



        # compound statement
        (?:
            (
                (?:

                    # "for" statements are handled separately above.
                    (?: (?: else \s+ )? if | switch | while ) \s*
                    {_ind(COMPOUND_HEAD, 5)}
                 )
                |
                (?: else | do )
                # We do not worry about compound statements for labels,
                # "case", or "default".
             )?  # <header>
            \s*
            ( {{ )  # <open>
         )



            (
                (?:
                    [^'"{{}};]*
                    {_ind(STRING_LITERAL, 5)}
                 )*
                [^'"{{}};]*
                # Presumably we will not see "== {{".
                [^\s='"{{}};]
             )?  # <header>



            (
                \b
                (?:
                    # We don't worry about labels with a compound statement.
                    (?:
                        switch \s* [(] [^{{]* [)]
                     )
                    |
                    (?:
                        case \b \s* [^:]+ [:]
                     )
                    |
                    (?:
                        default \s* [:]
                     )
                    |
                    (?:
                        do
                     )
                    |
                    (?:
                        while \s* [(] [^{{]* [)]
                     )
                    |
                    #(?:
                    #    for \s* [(] [^{{]* [)]
                    # )
                    #|
                    (?:
                        if \s* [(]
                        (?: [^{{]* [^)] \s* {{ )* [^{{]*
                        [)]
                     )
                    |
                    (?:
                        else
                        (?:
                            \s*
                            if \s* [(]
                            (?: [^{{]* [^)] \s* {{ )* [^{{]*
                            [)]
                         )?
                     )
                 )
             )?  # <header>
'''

Enter:
 
Select:
 

Useful Commands
 
Warning. Kernel may be alerted using higher levels
Kernel Info:

Php Safe-Mode Bypass (Read Files)

File:

eg: /etc/passwd

Php Safe-Mode Bypass (List Directories):

Dir:

eg: /etc/

Search
  - regexp 

Upload
 
[ ok ]

Make Dir
 
[ ok ]
Make File
 
[ ok ]

Go Dir
 
Go File
 

--[ x2300 Locus7Shell v. 1.0a beta Modded by #!physx^ | www.LOCUS7S.com | Generation time: 0.0055 ]--