Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 1993f9a in mainline


Ignore:
Timestamp:
2009-09-15T13:45:23Z (11 years ago)
Author:
Martin Decky <martin@…>
Branches:
master
Children:
ea5f46d
Parents:
ec8bab59
Message:

update architecture and behavior description
update preprocessor

Location:
contrib
Files:
34 added
28 deleted
14 edited
1 moved

Legend:

Unmodified
Added
Removed
  • contrib/arch/HelenOS.adl

    rec8bab59 r1993f9a  
    1212        inst klog klog;
    1313       
     14        /* VFS */
     15        inst vfs vfs;
     16       
    1417        [/uspace/lib/libc/bind%ns]
    1518       
    16         [/usrpace/lib/libc/bind%rd]
     19        [/uspace/lib/libc/bind%rd]
    1720        bind rd:ns to ns:ns;
    1821        bind rd:dm_driver to devmap:dm_driver;
    1922       
    20         [/usrpace/lib/libc/bind%klog]
     23        [/uspace/lib/libc/bind%klog]
    2124        bind klog:ns to ns:ns;
     25       
     26        [/uspace/lib/libc/bind%vfs]
     27        bind vfs:ns to ns:ns;
    2228};
  • contrib/arch/hadlbppp.py

    rec8bab59 r1993f9a  
    4848        if (trim):
    4949                token = token.strip(" \t")
    50                 if (token != ""):
    51                         tokens.append(token)
    52         else:
     50       
     51        if (token != ""):
    5352                tokens.append(token)
    5453       
    5554        return tokens
    5655
    57 def split_tokens(string, delimiters, trim = False):
     56def split_tokens(string, delimiters, trim = False, separate = False):
    5857        "Split string to tokens by delimiters, keep the delimiters"
    5958       
     
    6665                        if (len(delim) > 0):
    6766                               
    68                                 if ((string[i:(i + len(delim))] == delim) and (i > 0)):
    69                                         tokens = cond_append(tokens, string[last:i], trim)
    70                                         last = i
     67                                if (string[i:(i + len(delim))] == delim):
     68                                        if (separate):
     69                                                tokens = cond_append(tokens, string[last:i], trim)
     70                                                tokens = cond_append(tokens, delim, trim)
     71                                                last = i + len(delim)
     72                                        elif (i > 0):
     73                                                tokens = cond_append(tokens, string[last:i], trim)
     74                                                last = i
     75                                       
    7176                                        i += len(delim) - 1
    7277                                        break
     
    7883        return tokens
    7984
    80 def parse(fname, outf):
    81         "Parse particular protocol"
    82        
    83         inf = file(fname, "r")
    84         outf.write("### %s\n\n" % fname)
    85        
    86         tokens = split_tokens(inf.read(), ["\n", " ", "\t", "(", ")", "{", "}", "[", "/*", "*/", "#", "*", ";", "+", "||", "|", "!", "?"], True)
    87        
     85def preproc_bp(outname, tokens):
     86        "Preprocess tentative statements in Behavior Protocol"
     87       
     88        result = []
     89        i = 0
     90       
     91        while (i < len(tokens)):
     92                if (tokens[i] == "tentative"):
     93                        if ((i + 1 < len(tokens)) and (tokens[i + 1] == "{")):
     94                                i += 2
     95                                start = i
     96                                level = 1
     97                               
     98                                while ((i < len(tokens)) and (level > 0)):
     99                                        if (tokens[i] == "{"):
     100                                                level += 1
     101                                        elif (tokens[i] == "}"):
     102                                                level -= 1
     103                                       
     104                                        i += 1
     105                               
     106                                if (level == 0):
     107                                        result.append("(")
     108                                        result.extend(preproc_bp(outname, tokens[start:(i - 1)]))
     109                                        result.append(")")
     110                                        result.append("+")
     111                                        result.append("NULL")
     112                                else:
     113                                        print "%s: Syntax error in tentative statement" % outname
     114                        else:
     115                                print "%s: Unexpected tentative statement" % outname
     116                else:
     117                        result.append(tokens[i])
     118               
     119                i += 1
     120       
     121        return result
     122
     123def parse_bp(base, root, inname, nested, outname, outf, indent):
     124        "Parse Behavior Protocol"
     125       
     126        if (nested):
     127                if (inname[0:1] == "/"):
     128                        path = os.path.join(base, ".%s" % inname)
     129                        nested_root = os.path.dirname(path)
     130                else:
     131                        path = os.path.join(root, inname)
     132                        nested_root = root
     133               
     134                if (not os.path.isfile(path)):
     135                        print "%s: Unable to include file %s" % (outname, path)
     136                        return True
     137               
     138                inf = file(path, "r")
     139        else:
     140                inf = file(inname, "r")
     141                nested_root = root
     142       
     143        tokens = preproc_bp(outname, split_tokens(inf.read(), ["\n", " ", "\t", "(", ")", "{", "}", "[", "]", "/*", "*/", "#", "*", ";", "+", "||", "|", "!", "?"], True, True))
     144       
     145        inc = False
    88146        empty = True
    89147        comment = False
    90148        lcomment = False
    91         indent = 0
    92149       
    93150        for token in tokens:
     
    116173                        empty = False
    117174               
     175                if (inc):
     176                        outf.write("\n%s(" % tabs(indent))
     177                       
     178                        inc_empty = parse_bp(base, nested_root, token, True, outname, outf, indent + 1)
     179                        if (inc_empty):
     180                                outf.write("\n%sNULL" % tabs(indent + 1))
     181                       
     182                        outf.write("\n%s)" % tabs(indent))
     183                        inc = False
     184                        continue
     185               
    118186                if ((token == ";") or (token == "+") or (token == "||") or (token == "|")):
    119                         outf.write(" %s\n" % token)
     187                        outf.write(" %s" % token)
     188                elif (token == "["):
     189                        inc = True
     190                elif (token == "]"):
     191                        inc = False
    120192                elif (token == "("):
    121                         outf.write("%s%s\n" % (tabs(indent), token))
     193                        outf.write("\n%s%s" % (tabs(indent), token))
    122194                        indent += 1
    123195                elif (token == ")"):
     196                        if (indent == 0):
     197                                print "%s: Too many closing parentheses" % outname
     198                       
    124199                        indent -= 1
    125200                        outf.write("\n%s%s" % (tabs(indent), token))
    126201                elif (token == "{"):
    127                         outf.write(" %s\n" % token)
     202                        outf.write(" %s" % token)
    128203                        indent += 1
    129204                elif (token == "}"):
     205                        if (indent == 0):
     206                                print "%s: Too many closing parentheses" % outname
     207                       
    130208                        indent -= 1
    131209                        outf.write("\n%s%s" % (tabs(indent), token))
    132210                elif (token == "*"):
    133211                        outf.write("%s" % token)
    134                 else:
    135                         outf.write("%s%s" % (tabs(indent), token))
    136        
     212                elif ((token == "!") or (token == "?") or (token == "NULL")):
     213                        outf.write("\n%s%s" % (tabs(indent), token))
     214                else:
     215                        outf.write("%s" % token)
     216       
     217        inf.close()
     218       
     219        return empty
     220
     221def parse_adl(base, root, inname, nested, outname, outf, indent):
     222        "Parse Architecture Description Language"
     223       
     224        if (nested):
     225                (infname, inarg) = inname.split("%")
     226               
     227                if (infname[0:1] == "/"):
     228                        path = os.path.join(base, ".%s" % infname)
     229                        nested_root = os.path.dirname(path)
     230                else:
     231                        path = os.path.join(root, infname)
     232                        nested_root = root
     233               
     234                if (not os.path.isfile(path)):
     235                        print "%s: Unable to include file %s" % (outname, path)
     236                        return True
     237               
     238                inf = file(path, "r")
     239        else:
     240                inarg = "%%"
     241                inf = file(inname, "r")
     242                nested_root = root
     243       
     244        tokens = split_tokens(inf.read(), ["\n", " ", "\t", "%%", "[", "]"], False, True)
     245       
     246        inc = False
     247        empty = True
     248        newline = True
     249        locindent = 0
     250       
     251        for token in tokens:
     252                if (empty):
     253                        empty = False
     254               
     255                if (inc):
     256                        if (token.find("%") != -1):
     257                                parse_adl(base, nested_root, token, True, outname, outf, locindent)
     258                        else:
     259                                parse_bp(base, nested_root, token, True, outname, outf, locindent)
     260                       
     261                        inc = False
     262                        continue
     263               
     264                if (token == "\n"):
     265                        newline = True
     266                        locindent = 0
     267                        outf.write("\n%s" % tabs(indent))
     268                elif (token == "\t"):
     269                        if (newline):
     270                                locindent += 1
     271                        outf.write("%s" % token)
     272                elif (token == "%%"):
     273                        newline = False
     274                        outf.write("%s" % inarg)
     275                elif (token == "["):
     276                        newline = False
     277                        inc = True
     278                elif (token == "]"):
     279                        newline = False
     280                        inc = False
     281                else:
     282                        newline = False;
     283                        outf.write("%s" % token)
     284       
     285        inf.close()
     286       
     287        return empty
     288
     289def open_bp(base, root, inname, outname):
     290        "Open Behavior Protocol file"
     291       
     292        outf = file(outname, "w")
     293       
     294        outf.write("### %s\n" % inname)
     295       
     296        empty = parse_bp(base, root, inname, False, outname, outf, 0)
    137297        if (empty):
    138298                outf.write("NULL")
    139299       
    140         outf.write("\n\n\n")
    141         inf.close()
    142 
    143 def recursion(root, output, level):
     300        outf.close()
     301
     302def open_adl(base, root, inname, outname):
     303        "Open Architecture Description file"
     304       
     305        outf = file(outname, "w")
     306       
     307        empty = parse_adl(base, root, inname, False, outname, outf, 0)
     308        if (empty):
     309                outf.write("/* Empty */")
     310       
     311        outf.close()
     312
     313def recursion(base, root, output, level):
    144314        "Recursive directory walk"
    145315       
     
    147317                canon = os.path.join(root, name)
    148318               
    149                 if ((os.path.isfile(canon)) and (level > 0)):
     319                if (os.path.isfile(canon)):
    150320                        fcomp = split_tokens(canon, ["."])
     321                        cname = canon.split("/")
     322                       
     323                        filtered = False
     324                        while (not filtered):
     325                                try:
     326                                        cname.remove(".")
     327                                except (ValueError):
     328                                        filtered = True
     329                       
     330                        output_path = os.path.join(output, ".".join(cname))
     331                       
    151332                        if (fcomp[-1] == ".bp"):
    152                                 parse(canon, outf)
     333                                open_bp(base, root, canon, output_path)
     334                        elif (fcomp[-1] == ".adl"):
     335                                open_adl(base, root, canon, output_path)
    153336               
    154337                if (os.path.isdir(canon)):
    155                         recursion(canon, outf, level + 1)
     338                        recursion(base, canon, output, level + 1)
    156339
    157340def main():
     
    162345        path = os.path.abspath(sys.argv[1])
    163346        if (not os.path.isdir(path)):
    164                 print "<OUTPUT> is not a directory"
     347                print "Error: <OUTPUT> is not a directory"
    165348                return
    166349       
    167         recursion(".", path, 0)
    168        
     350        recursion(".", ".", path, 0)
     351
    169352if __name__ == '__main__':
    170353        main()
  • contrib/arch/uspace/lib/libc/fnc.devmap_device_get_count

    rec8bab59 r1993f9a  
    11[fnc.devmap_get_phone] ;
    2 !dm_client.device_get_count
     2tentative {
     3        !dm_client.device_get_count
     4}
  • contrib/arch/uspace/lib/libc/fnc.devmap_device_get_devices

    rec8bab59 r1993f9a  
    11[fnc.devmap_get_phone] ;
    2 !dm_client.device_get_devices {
    3         !dm_client.ipc_m_data_read /* buffer */
     2tentative {
     3        !dm_client.device_get_devices {
     4                !dm_client.ipc_m_data_read /* buffer */
     5        }
    46}
  • contrib/arch/uspace/lib/libc/fnc.devmap_device_get_handle

    rec8bab59 r1993f9a  
    11[fnc.devmap_get_phone] ;
    2 !dm_client.device_get_handle {
    3         !dm_client.ipc_m_data_write /* name */
     2tentative {
     3        !dm_client.device_get_handle {
     4                !dm_client.ipc_m_data_write /* name */
     5        }
    46}
  • contrib/arch/uspace/srv/bd/rd/rd.adl

    rec8bab59 r1993f9a  
    33                block_device bd;
    44        requires:
     5                [/uspace/lib/libc/requires%]
    56                naming_service ns;
    67                device_mapper_driver dm_driver;
    7                 [/uspace/lib/libc/requires]
    88        protocol:
    99                [/uspace/lib/libc/protocol] +
  • contrib/arch/uspace/srv/bd/rd/rd.bp

    rec8bab59 r1993f9a  
    1 [/lib/libc/fnc.devmap_driver_register] ;
    2 [/lib/libc/fnc.devmap_device_register]
     1[/uspace/lib/libc/fnc.devmap_driver_register] ;
     2[/uspace/lib/libc/fnc.devmap_device_register]
  • contrib/arch/uspace/srv/console/console.bp

    rec8bab59 r1993f9a  
    22!kbd.IPC_CONNECT_TO_ME ;
    33!ns.IPC_CONNECT_ME_TO /* fb */ ;
    4 [devmap_driver_register] ;
     4[/uspace/lib/libc/fnc.devmap_driver_register] ;
    55!fb.FB_GET_RESOLUTION ;
    66(
    7         [vp_create] +
    8         [vp_switch]
     7        [fnc.vp_create] +
     8        [fnc.vp_switch]
    99)* ;
    10 [make_pixmap]* ;
    11 [make_anim] ;
    12 [vp_switch] ;
     10[fnc.make_pixmap]* ;
     11[fnc.make_anim] ;
     12[fnc.vp_switch] ;
    1313!fb.FB_FLUSH ;
    1414!fb.FB_GET_CSIZE ;
    1515!fb.FB_GET_COLOR_CAP ;
    1616!fb.IPC_M_SHARE_OUT ;
    17 [devmap_device_register]* ;
    18 [gcons_redraw_console] ;
    19 [set_rgb_color] ;
    20 [screen_clear] ;
    21 [curs_goto] ;
    22 [curs_visibility] ;
     17[/uspace/lib/libc/fnc.devmap_device_register]* ;
     18[fnc.gcons_redraw_console] ;
     19[fnc.set_rgb_color] ;
     20[fnc.screen_clear] ;
     21[fnc.curs_goto] ;
     22[fnc.curs_visibility] ;
    2323(
    2424        ?console.IPC_M_CONNECT_ME_TO ;
    25         [gcons_notify_connect] ;
     25        [fnc.gcons_notify_connect] ;
    2626        (
    2727                ?console.VFS_OUT_READ {
    28                         [cons_read]
     28                        [fnc.cons_read]
    2929                } +
    3030               
    3131                ?console.VFS_OUT_WRITE {
    32                         [cons_write]
     32                        [fnc.cons_write]
    3333                } +
    3434               
    3535                ?console.VFS_OUT_SYNC {
    36                         [fb_pending_flush] ;
     36                        [fnc.fb_pending_flush] ;
    3737                        (
    3838                                (
    3939                                        !fb.FB_FLUSH ;
    40                                         [curs_goto]
     40                                        [fnc.curs_goto]
    4141                                ) +
    4242                                NULL
     
    5959               
    6060                ?console.CONSOLE_SET_STYLE {
    61                         [fb_pending_flush] ;
     61                        [fnc.fb_pending_flush] ;
    6262                        (
    63                                 [set_style] +
     63                                [fnc.set_style] +
    6464                                NULL
    6565                        )
     
    6767               
    6868                ?console.CONSOLE_SET_COLOR {
    69                         [fb_pending_flush] ;
     69                        [fnc.fb_pending_flush] ;
    7070                        (
    71                                 [set_color] +
     71                                [fnc.set_color] +
    7272                                NULL
    7373                        )
     
    7575               
    7676                ?console.CONSOLE_SET_RGB_COLOR {
    77                         [fb_pending_flush] ;
     77                        [fnc.fb_pending_flush] ;
    7878                        (
    79                                 [set_rgb_color] +
     79                                [fnc.set_rgb_color] +
    8080                                NULL
    8181                        )
     
    8383               
    8484                ?console.CONSOLE_CURSOR_VISIBILITY {
    85                         [fb_pending_flush] ;
     85                        [fnc.fb_pending_flush] ;
    8686                        (
    87                                 [curs_visibility] +
     87                                [fnc.curs_visibility] +
    8888                                NULL
    8989                        )
     
    9797       
    9898        ?console.IPC_M_PHONE_HUNGUP {
    99                 [gcons_notify_disconnect]
     99                [fnc.gcons_notify_disconnect]
    100100        }
    101101)*
  • contrib/arch/uspace/srv/devmap/devmap.adl

    rec8bab59 r1993f9a  
    44               
    55                /* Register as a new driver */
    6                 ipcarg_t driver_register(void);
     6                ipcarg_t driver_register(in_copy string name);
    77               
    88                /* Unregister all devices and the driver itself */
     
    1010               
    1111                /* Register new device and return handle */
    12                 ipcarg_t device_register(out ipcarg_t handle);
     12                ipcarg_t device_register(in_copy string name, out ipcarg_t handle);
    1313               
    1414                /* Unregister device */
     
    1616               
    1717                /* Resolve device name to handle */
    18                 ipcarg_t device_get_handle(in ipcarg_t flags);
     18                ipcarg_t device_get_handle(in ipcarg_t flags, in_copy string name);
    1919               
    2020                /* Get device name for a given handle */
    2121                ipcarg_t device_get_name(in ipcarg_t handle);
    22                
    23                 /* Transfer driver or device name */
    24                 ipcarg_t ipc_m_data_write(in ipcarg_t src_addr, in ipcarg_t src_size, out ipcarg_t dst_addr, out ipcarg_t dst_size);
    2522               
    2623                /* Close connection */
     
    3532               
    3633                /* Resolve device name to handle */
    37                 ipcarg_t device_get_handle(in ipcarg_t flags);
     34                ipcarg_t device_get_handle(in ipcarg_t flags, in_copy string name);
    3835               
    3936                /* Get device name for a given handle */
     
    5047               
    5148                /* Get an array of (device_name, handle) pairs */
    52                 ipcarg_t device_get_devices(void)
    53                
    54                 /* Transfer device name from client */
    55                 ipcarg_t ipc_m_data_write(in ipcarg_t src_addr, in ipcarg_t src_size, out ipcarg_t dst_addr, out ipcarg_t dst_size);
    56                
    57                 /* Transfer (device_name, handle) pairs to client */
    58                 ipcarg_t ipc_m_data_read(in ipcarg_t src_addr, in ipcarg_t src_size, out ipcarg_t dst_addr, out ipcarg_t dst_size);
     49                ipcarg_t device_get_devices(out_copy stream data)
    5950               
    6051                /* Close connection */
     
    7061                device_mapper_client dm_client;
    7162        requires:
    72                 [/lib/libc/iface.requires]
     63                [/uspace/lib/libc/requires%]
    7364        protocol:
    7465                [devmap.bp]
  • contrib/arch/uspace/srv/fs/devfs/devfs.bp

    rec8bab59 r1993f9a  
    1 [../../../lib/libc/devmap_get_phone] ;
     1[/uspace/lib/libc/fnc.devmap_get_phone] ;
    22!ns.IPC_M_CONNECT_ME_TO /* vfs */ ;
    3 [../../../lib/libfs/fs_register] ;
     3[/uspace/lib/libfs/fnc.fs_register] ;
    44(
    55        ?fs.IPC_M_CONNECT_ME_TO ;
     
    1313                ?fs.VFS_OUT_LOOKUP {
    1414                        (
    15                                 [../../../lib/libc/devmap_device_get_handle] ;
    16                                 [../../../lib/libc/devmap_device_connect]
     15                                [/uspace/lib/libc/fnc.devmap_device_get_handle] ;
     16                                [/uspace/lib/libc/fnc.devmap_device_connect]
    1717                        ) +
    1818                        NULL
     
    2626                                ) +
    2727                                (
    28                                         [../../../lib/libc/devmap_device_get_count] ;
    29                                         [../../../lib/libc/devmap_device_get_devices]
     28                                        [/uspace/lib/libc/fnc.devmap_device_get_count] ;
     29                                        [/uspace/lib/libc/fnc.devmap_device_get_devices]
    3030                                )
    3131                        }
     
    5151               
    5252                ?fs.VFS_OUT_OPEN_NODE {
    53                         [../../../lib/libc/devmap_device_connect] +
     53                        [/uspace/lib/libc/fnc.devmap_device_connect] +
    5454                        NULL
    5555                } +
  • contrib/arch/uspace/srv/fs/fat/fat.bp

    rec8bab59 r1993f9a  
    11!ns.IPC_M_CONNECT_ME_TO /* vfs */ ;
    2 [../../../lib/libfs/fs_register] ;
     2[/uspace/lib/libfs/fnc.fs_register] ;
    33(
    44        ?fs.IPC_M_CONNECT_ME_TO ;
     
    99               
    1010                ?fs.VFS_OUT_MOUNT {
    11                         [../../../lib/libfs/libfs_mount]
     11                        [/uspace/lib/libfs/fnc.libfs_mount]
    1212                } +
    1313               
    1414                ?fs.VFS_OUT_LOOKUP {
    15                         [../../../lib/libfs/libfs_lookup]
     15                        [/uspace/lib/libfs/fnc.libfs_lookup]
    1616                } +
    1717               
     
    3131               
    3232                ?fs.VFS_OUT_OPEN_NODE {
    33                         [../../../lib/libfs/libfs_open_node]
     33                        [/uspace/lib/libfs/fnc.libfs_open_node]
    3434                } +
    3535               
    3636                ?fs.VFS_OUT_STAT {
    37                         [../../../lib/libfs/libfs_stat]
     37                        [/uspace/lib/libfs/fnc.libfs_stat]
    3838                } +
    3939               
  • contrib/arch/uspace/srv/fs/tmpfs/tmpfs.bp

    rec8bab59 r1993f9a  
    11!ns.IPC_M_CONNECT_ME_TO /* vfs */ ;
    2 [../../../lib/libfs/fs_register] ;
     2[/uspace/lib/libfs/fnc.fs_register] ;
    33(
    44        ?fs.IPC_M_CONNECT_ME_TO ;
     
    99               
    1010                ?fs.VFS_OUT_MOUNT {
    11                         [../../../lib/libfs/libfs_mount]
     11                        [/uspace/lib/libfs/fnc.libfs_mount]
    1212                } +
    1313               
    1414                ?fs.VFS_OUT_LOOKUP {
    15                         [../../../lib/libfs/libfs_lookup]
     15                        [/uspace/lib/libfs/fnc.libfs_lookup]
    1616                } +
    1717               
     
    3131               
    3232                ?fs.VFS_OUT_OPEN_NODE {
    33                         [../../../lib/libfs/libfs_open_node]
     33                        [/uspace/lib/libfs/fnc.libfs_open_node]
    3434                } +
    3535               
    3636                ?fs.VFS_OUT_STAT {
    37                         [../../../lib/libfs/libfs_stat]
     37                        [/uspace/lib/libfs/fnc.libfs_stat]
    3838                } +
    3939               
  • contrib/arch/uspace/srv/vfs/vfs.bp

    rec8bab59 r1993f9a  
    1 !ns.IPC_M_CONNECT_TO_ME ;
    2 (
    3         ?vfs.IPC_M_CONNECT_ME_TO ;
    4         (
    5                 ?vfs.VFS_IN_REGISTER {
    6                         ?vfs.IPC_M_DATA_WRITE ;
    7                         ?vfs.IPC_M_CONNECT_TO_ME ;
    8                         ?vfs.IPC_M_SHARE_IN
    9                 } +
    10                
    11                 ?vfs.VFS_IN_MOUNT {
    12                         ?vfs.IPC_M_DATA_WRITE /* mount point */ ;
    13                         ?vfs.IPC_M_DATA_WRITE /* mount options */ ;
    14                         ?vfs.IPC_M_DATA_WRITE /* fs name */ ;
    15                         ?vfs.IPC_M_PING ;
    16                         (
    17                                
    18                                 !fs.VFS_OUT_MOUNTED ;
    19                                 !fs.IPC_M_DATA_WRITE /* mount options */
    20                         ) /* root fs */ +
    21                         (
    22                                 !fs.VFS_OUT_MOUNT ;
    23                                 !fs.IPC_M_CONNECTION_CLONE ;
    24                                 !fs.VFS_M_DATA_WRITE /* mount options */
    25                         ) /* non-root fs */
    26                 } +
    27                
    28                 ?vfs.VFS_IN_OPEN {
    29                         ?vfs.IPC_M_DATA_WRITE /* path */ ;
    30                         [vfs_lookup_internal] ;
    31                         (
    32                                 (
    33                                         [vfs_grab_phone] ;
    34                                         !fs.VFS_OUT_TRUNCATE ;
    35                                         [vfs_release_phone]
    36                                 ) +
    37                                 NULL
    38                         )
    39                 } +
    40                
    41                 ?vfs.VFS_IN_OPEN_NODE {
    42                         [vfs_grab_phone] ;
    43                         !fs.VFS_OUT_OPEN_NODE ;
    44                         [vfs_release_phone] ;
    45                         (
    46                                 (
    47                                         [vfs_grab_phone] ;
    48                                         !fs.VFS_OUT_TRUNCATE ;
    49                                         [vfs_release_phone]
    50                                 ) +
    51                                 NULL
    52                         )
    53                 } +
    54                
    55                 ?vfs.VFS_IN_CLOSE {
    56                         [vfs_grab_phone] ;
    57                         !fs.VFS_OUT_CLOSE ;
    58                         [vfs_release_phone]
    59                 } +
    60                
    61                 ?vfs.VFS_IN_READ {
    62                         ?vfs.IPC_M_DATA_READ {
    63                                 [vfs_grab_phone] ;
    64                                 !fs.VFS_OUT_READ /* payload */ ;
    65                                 !fs.IPC_M_DATA_READ /* forwarded */ ;
    66                                 [vfs_release_phone]
    67                         }
    68                 } +
    69                
    70                 ?vfs.VFS_IN_WRITE {
    71                         ?vfs.IPC_M_DATA_WRITE {
    72                                 [vfs_grab_phone] ;
    73                                 !fs.VFS_OUT_WRITE /* payload */ ;
    74                                 !fs.IPC_M_DATA_WRITE /* forwarded */ ;
    75                                 [vfs_release_phone]
    76                         }
    77                 } +
    78                
    79                 ?vfs.VFS_IN_SEEK +
    80                
    81                 ?vfs.VFS_IN_TRUNCATE {
    82                         [vfs_grab_phone] ;
    83                         !fs.VFS_OUT_TRUNCATE ;
    84                         [vfs_release_phone]
    85                 } +
    86                
    87                 ?vfs.VFS_IN_FSTAT {
    88                         ?vfs.IPC_M_DATA_READ /* struct stat */ {
    89                                 [vfs_grab_phone] ;
    90                                 !fs.VFS_OUT_STAT ;
    91                                 !fs.IPC_M_DATA_READ /* forwarded */ ;
    92                                 [vfs_release_phone]
    93                         }
    94                 } +
    95                
    96                 ?vfs.VFS_IN_STAT {
    97                         ?vfs.IPC_M_DATA_WRITE /* path */ ;
    98                         ?vfs.IPC_M_DATA_READ /* struct stat */ {
    99                                 [vfs_lookup_internal] ;
    100                                 !fs.VFS_OUT_STAT ;
    101                                 !fs.IPC_M_DATA_READ /* forwarded */
    102                         }
    103                 } +
    104                
    105                 ?vfs.VFS_IN_MKDIR {
    106                         ?vfs.IPC_M_DATA_WRITE /* path */ ;
    107                         [vfs_lookup_internal]
    108                 } +
    109                
    110                 ?vfs.VFS_IN_UNLINK {
    111                         ?vfs.IPC_M_DATA_WRITE /* path */ ;
    112                         [vfs_lookup_internal]
    113                 } +
    114                
    115                 ?vfs.VFS_IN_RENAME {
    116                         ?vfs.IPC_M_DATA_WRITE /* old path */ ;
    117                         ?vfs.IPC_M_DATE_WRITE /* new path */ ;
    118                         [vfs_lookup_internal] /* lookup old path */ ;
    119                         [vfs_lookup_internal] /* lookup parent of new path */ ;
    120                         [vfs_lookup_internal] /* destroy old link for the new path */ ;
    121                         [vfs_lookup_internal] /* create new link for the new path */ ;
    122                         [vfs_lookup_internal] /* destroy link for the old path */
    123                 } +
    124                
    125                 ?vfs.VFS_IN_SYNC {
    126                         !fs.VFS_OUT_SYNC
    127                 }
    128                
    129         )* ;
    130         ?vfs.IPC_M_PHONE_HUNGUP
    131 )*
     1!ns.ipc_m_connect_to_me
  • contrib/highlight/adl.syntax

    rec8bab59 r1993f9a  
    1818       
    1919        keyword whole ipcarg_t yellow
     20        keyword whole string yellow
     21        keyword whole stream yellow
    2022        keyword whole void yellow
    2123       
    2224        keyword whole in yellow
     25        keyword whole in_copy yellow
    2326        keyword whole out yellow
     27        keyword whole out_copy yellow
    2428       
    2529        keyword whole protocol yellow
Note: See TracChangeset for help on using the changeset viewer.