summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lib9p/9p.generated.c18
-rw-r--r--lib9p/idl/0000-README.md63
-rw-r--r--lib9p/idl/0000-TODO.md2
-rw-r--r--lib9p/idl/1992-9P0.9p.wip56
-rw-r--r--lib9p/idl/1995-9P1.9p.wip2
-rw-r--r--lib9p/idl/1996-Styx.9p.wip2
-rw-r--r--lib9p/idl/2002-9P2000.9p81
-rw-r--r--lib9p/idl/2005-9P2000.u.9p14
-rw-r--r--lib9p/idl/2010-9P2000.L.9p186
-rw-r--r--lib9p/idl/__init__.py522
-rw-r--r--lib9p/include/lib9p/9p.generated.h605
-rw-r--r--lib9p/protogen/c.py2
-rw-r--r--lib9p/protogen/c9util.py25
-rw-r--r--lib9p/protogen/c_marshal.py47
-rw-r--r--lib9p/protogen/c_unmarshal.py13
-rw-r--r--lib9p/protogen/c_validate.py28
-rw-r--r--lib9p/protogen/h.py264
-rw-r--r--lib9p/srv.c10
-rw-r--r--lib9p/tests/test_compile.c192
19 files changed, 1319 insertions, 813 deletions
diff --git a/lib9p/9p.generated.c b/lib9p/9p.generated.c
index 6726084..8819458 100644
--- a/lib9p/9p.generated.c
+++ b/lib9p/9p.generated.c
@@ -275,19 +275,19 @@ const char *const _lib9p_table_msg_name[LIB9P_VER_NUM][0x100] = {
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_dm_t dm_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
- [LIB9P_VER_9P2000] = 0b11101100000000000000000111111111,
+ [LIB9P_VER_9P2000] = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
[LIB9P_VER_9P2000_L] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
- [LIB9P_VER_9P2000_e] = 0b11101100000000000000000111111111,
+ [LIB9P_VER_9P2000_e] = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
- [LIB9P_VER_9P2000_p9p] = 0b11101100000000000000000111111111,
+ [LIB9P_VER_9P2000_p9p] = 0b11111100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
- [LIB9P_VER_9P2000_u] = 0b11101100101111000000000111111111,
+ [LIB9P_VER_9P2000_u] = 0b11111100101111000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};
@@ -295,19 +295,19 @@ static const lib9p_dm_t dm_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_qt_t qt_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
- [LIB9P_VER_9P2000] = 0b11101100,
+ [LIB9P_VER_9P2000] = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
- [LIB9P_VER_9P2000_L] = 0b11101100,
+ [LIB9P_VER_9P2000_L] = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
- [LIB9P_VER_9P2000_e] = 0b11101100,
+ [LIB9P_VER_9P2000_e] = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
- [LIB9P_VER_9P2000_p9p] = 0b11101100,
+ [LIB9P_VER_9P2000_p9p] = 0b11111100,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
- [LIB9P_VER_9P2000_u] = 0b11101110,
+ [LIB9P_VER_9P2000_u] = 0b11111110,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};
diff --git a/lib9p/idl/0000-README.md b/lib9p/idl/0000-README.md
index e19a1e8..84cf865 100644
--- a/lib9p/idl/0000-README.md
+++ b/lib9p/idl/0000-README.md
@@ -17,35 +17,62 @@ client->server requests, and R-messages are server->client responses
type of a message is represented by a u8 ID; T-messages are even and
R-messages are odd.
-Messages are made up of the primitives; unsigned little-endian
-integers, identified with the following single-character mnemonics:
+9P messages are exchanged over a reliable bidirectional in-order octet
+stream. Messages are made up of the primitives; unsigned
+little-endian integers, identified with the following single-character
+mnemonics:
- 1 = u8
- 2 = u16le
- 4 = u32le
- 8 = u16le
-Out of these primitives, we can make other numeric types,
+Out of these primitives, we can make more complex types:
+
+## User-defined types
+
+### Numeric types
num NUMNAME = PRIMITIVE_TYPE
+ "NAME=VAL"...
+
+Besides just being an alias for a primitive type, a numeric type may
+define 0 or more named constants of that type, each wrapped in
+"quotes".
+
+### Bitfields
-bitfields,
+ bitfield BFNAME = PRIMITIVE_TYPE
+ "bit NBIT=NAME"...
+ "bit NBIT=reserved(NAME)"...
+ "bit NBIT=num(NUMNAME)"...
+ "alias NAME=VAL"...
+ "mask NAME=VAL"...
+ "num(NUMNAME) NAME=VAL"...
- bitfield BFNAME = PRIMITIVE_TYPE "NBIT=NAME... ALIAS=VAL..."
+The same NBIT may not be defined multiple times. The same NAME may
+not be defined multiple times.
-structures,
+ - A `reserved(...)` bit indicates that the bit is named but is not
+ allowed to be used.
+ - `num(...)` bits embed a numeric/enumerated field within a set of
+ bits. Once several bits have been allocated to a numeric field
+ with `bit NBIT=num(NUMNAME)`, constant values for that field may be
+ declared with `num(NUMNAME) NAME=VAL`. For each numeric field, a
+ `mask NUMNAME=BITMASK` is automatically declared.
+ - A `mask` defines a bitmask that selects several bits.
+ - An `alias` defines a convenience alias for a bit or set of bits.
+
+### Structures
struct STRUCTNAME = "FIELDNAME[FIELDTYPE]..."
-and messages (which are a special-case of structures).
+Or a special-case for structs that are messages; `msg` has the same
+syntax as `struct`, but has restrictions on the STRUCTNAME and the
+first 3 fields must all be declared in the same way:
msg Tname = "size[4,val=end-&size] typ[1,val=TYP] tag[tag] REST..."
-Bitfield bit names may be wrapped in `reserved(...)` or
-`subfield(...)`; reserved indicates that the bit is named but is not
-allowed to be used, and subfield indicates that the bit is part of a
-num/enum that is handled by an alias.
-
Struct fields that have numeric types (either primitives or `num`
types) can add to their type `,val=` and/or `,max=` to specify what
the exact value must be and/or what the maximum (inclusive) value is.
@@ -59,11 +86,13 @@ can be
- `&fieldname` to refer to the offset of a field name in that struct,
- the special value `end` to refer to the offset of the end of the
struct,
- - the special value `s32_max` to refer to the constant value
- `(1<<31)-1`, or
- - the special value `s64_max` to refer to the constant value
- `(1<<63)-1`
+ - the special value `u{8,16,32,64}_max` to refer to the constant
+ value `(1<<{n})-1`, or
+ - the special value `s{8,16,32,64}_max` to refer to the constant value
+ `(1<<({n}-1))-1`.
+
+## Parser
A parser for this syntax is given in `__init__.py`. However,
`__init__.py` places the somewhat arbitrary undocumented restrictions
-on fields referenced as the count for a repeated field.
+on fields referenced as the count of a repeated field.
diff --git a/lib9p/idl/0000-TODO.md b/lib9p/idl/0000-TODO.md
index 81cafe5..e52902f 100644
--- a/lib9p/idl/0000-TODO.md
+++ b/lib9p/idl/0000-TODO.md
@@ -9,5 +9,3 @@
- Decide how to handle duplicate type names from different versions
- Decide how to handle duplicate `enum lib9p_msg_type` names and
values
-- Clean up the iterate-over-all-msgids-in-a-version code
-- Allow for const `.cnt` instead of only having previous-member `.cnt`
diff --git a/lib9p/idl/1992-9P0.9p.wip b/lib9p/idl/1992-9P0.9p.wip
index 086e8e4..a434ba2 100644
--- a/lib9p/idl/1992-9P0.9p.wip
+++ b/lib9p/idl/1992-9P0.9p.wip
@@ -37,40 +37,40 @@ struct errstr = "64*(txt[1])"
# "O"pen flags (flags to pass to Topen and Tcreate)
# Unused bits are *ignored*.
bitfield o = 1
- "0=mode_0" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
- "1=mode_1" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
- #"2=unused"
- #"3=unused"
- "4=TRUNC"
- #"5=_reserved_CEXEC" # close-on-exec
- "6=RCLOSE" # remove-on-close
- #"7=unused"
+ "bit 0=num(MODE)" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+ "bit 1=num(MODE)" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+ #"bit 2=unused"
+ #"bit 3=unused"
+ "bit 4=TRUNC"
+ "bit 5=reserved(CEXEC)" # close-on-exec
+ "bit 6=RCLOSE" # remove-on-close
+ #"bit 7=unused"
- "READ = 0" # make available for this FID: Tread()
- "WRITE = 1" # make available for this FID: Twrite()
- "RDWR = 2" # make available for this FID: Tread() and Twrite()
- "EXEC = 3" # make available for this FID: Tread()
+ "num(MODE) READ = 0" # make available for this FID: Tread()
+ "num(MODE) WRITE = 1" # make available for this FID: Twrite()
+ "num(MODE) RDWR = 2" # make available for this FID: Tread() and Twrite()
+ "num(MODE) EXEC = 3" # make available for this FID: Tread()
- "MODE_MASK = 0b00000011"
- "FLAG_MASK = 0b11111100"
+ "mask FLAG = 0b11111100"
-# "C"??? "H"??? - file permissions and attributes
+# "CH"annel flags - file permissions and attributes (a "channel" is
+# what a file handle is called inside of the Plan 9 kernel).
bitfield ch = 4
- "31=DIR"
- "30=APPEND"
- "29=EXCL"
+ "bit 31=DIR"
+ "bit 30=APPEND"
+ "bit 29=EXCL"
#...
- "8=OWNER_R"
- "7=OWNER_W"
- "6=OWNER_X"
- "5=GROUP_R"
- "4=GROUP_W"
- "3=GROUP_X"
- "2=OTHER_R"
- "1=OTHER_W"
- "0=OTHER_X"
+ "bit 8=OWNER_R"
+ "bit 7=OWNER_W"
+ "bit 6=OWNER_X"
+ "bit 5=GROUP_R"
+ "bit 4=GROUP_W"
+ "bit 3=GROUP_X"
+ "bit 2=OTHER_R"
+ "bit 1=OTHER_W"
+ "bit 0=OTHER_X"
- "PERM_MASK=0777" # {OWNER,GROUP,OTHER}_{R,W,X}
+ "mask PERM=0777" # {OWNER,GROUP,OTHER}_{R,W,X}
struct stat = "file_name[name]"
"file_owner[name]"
diff --git a/lib9p/idl/1995-9P1.9p.wip b/lib9p/idl/1995-9P1.9p.wip
index 2caf39d..660e24a 100644
--- a/lib9p/idl/1995-9P1.9p.wip
+++ b/lib9p/idl/1995-9P1.9p.wip
@@ -43,7 +43,7 @@ from ./1992-9P0.9p import tag, fid, qid, name, errstr, o, ch, stat
# draft RFC). As I understand it, CHMOUNT indicates that the file is
# mounted by the kernel as a 9P transport; that the kernel has a lock
# on doing I/O on it, so userspace can't do I/O on it.
-bitfield ch += "28=MOUNT"
+bitfield ch += "bit 28=_PLAN9_MOUNT"
# Authentication uses DES encryption. The client obtains a ticket and
# a nonce-key from a separate auth-server; how it does this is beyond
diff --git a/lib9p/idl/1996-Styx.9p.wip b/lib9p/idl/1996-Styx.9p.wip
index 6ba4509..3cb3774 100644
--- a/lib9p/idl/1996-Styx.9p.wip
+++ b/lib9p/idl/1996-Styx.9p.wip
@@ -40,7 +40,7 @@ msg Ropen = "typ[1,val=11] tag[tag] fid[fid] qid[qid]"
msg Tcreate = "typ[1,val=12] tag[tag] fid[fid] name[name] perm[ch] mode[o]"
msg Rcreate = "typ[1,val=13] tag[tag] fid[fid] qid[qid]"
# For `offset:max`, see `fs.c` `f_read()` and `f_write()`.
-# For `count:max`, see `styx.h:MAXFDATA'.
+# For `count:max`, see `styx.h:MAXFDATA`.
msg Tread = "typ[1,val=14] tag[tag] fid[fid] offset[8,max=s64_max] count[2,max=8192]"
msg Rread = "typ[1,val=15] tag[tag] fid[fid] count[2,max=8192] pad[1] count*(data[1])"
msg Twrite = "typ[1,val=16] tag[tag] fid[fid] offset[8,max=s64_max] count[2,max=8192] pad[1] count*(data[1])"
diff --git a/lib9p/idl/2002-9P2000.9p b/lib9p/idl/2002-9P2000.9p
index 2a4f7ed..36a2427 100644
--- a/lib9p/idl/2002-9P2000.9p
+++ b/lib9p/idl/2002-9P2000.9p
@@ -22,57 +22,57 @@ version "9P2000"
# tag - identify a request/response pair
num tag = 2
- "NOTAG = ~0"
+ "NOTAG = u16_max"
# file identifier - like a UNIX file-descriptor
num fid = 4
- "NOFID = ~0"
+ "NOFID = u32_max"
# string - u16le `n`, then `n` bytes of UTF-8, without any nul-bytes
struct s = "len[2] len*(utf8[1])"
# "D"ir-entry "M"ode - file permissions and attributes
bitfield dm = 4
- "31=DIR"
- "30=APPEND"
- "29=EXCL"
- # DMMOUNT has been around in Plan 9 forever (CHMOUNT in <4e),
+ "bit 31=DIR"
+ "bit 30=APPEND"
+ "bit 29=EXCL"
+ # DMMOUNT has been around in Plan 9 since 2e (CHMOUNT in <4e),
# but is undocumented, and is explicitly excluded from the
# 9P2000 draft RFC. As I understand it, DMMOUNT indicates
# that the file is mounted by the kernel as a 9P transport;
# that the kernel has a lock on doing I/O on it, so userspace
# can't do I/O on it.
- "28=reserved(PLAN9_MOUNT)"
- "27=AUTH"
- "26=TMP"
+ "bit 28=_PLAN9_MOUNT"
+ "bit 27=AUTH"
+ "bit 26=TMP"
#...
- "8=OWNER_R"
- "7=OWNER_W"
- "6=OWNER_X"
- "5=GROUP_R"
- "4=GROUP_W"
- "3=GROUP_X"
- "2=OTHER_R"
- "1=OTHER_W"
- "0=OTHER_X"
+ "bit 8=OWNER_R"
+ "bit 7=OWNER_W"
+ "bit 6=OWNER_X"
+ "bit 5=GROUP_R"
+ "bit 4=GROUP_W"
+ "bit 3=GROUP_X"
+ "bit 2=OTHER_R"
+ "bit 1=OTHER_W"
+ "bit 0=OTHER_X"
- "PERM_MASK=0777" # {OWNER,GROUP,OTHER}_{R,W,X}
+ "mask PERM=0777" # {OWNER,GROUP,OTHER}_{R,W,X}
# QID Type - see `struct qid` below
bitfield qt = 1
- "7=DIR"
- "6=APPEND"
- "5=EXCL"
- "4=reserved(PLAN9_MOUNT)" # See "PLAN9_MOUNT" in "dm" above.
- "3=AUTH"
+ "bit 7=DIR"
+ "bit 6=APPEND"
+ "bit 5=EXCL"
+ "bit 4=_PLAN9_MOUNT" # See "_PLAN9_MOUNT" in "dm" above.
+ "bit 3=AUTH"
# Fun historical fact: QTTMP was a relatively late addition to
# Plan 9, in 2003-12.
- "2=TMP"
- #"1=unused"
+ "bit 2=TMP"
+ #"bit 1=unused"
# "The name QTFILE, defined to be zero, identifies the value
# of the type for a plain file."
- "FILE=0"
+ "alias FILE=0"
# uni"Q"ue "ID"entification - "two files on the same server hierarchy
# are the same if and only if their qids are the same"
@@ -107,22 +107,21 @@ struct stat = "stat_size[2,val=end-&kern_type]"
# "O"pen flags (flags to pass to Topen and Tcreate)
# Unused bits *must* be 0.
bitfield o = 1
- "0=subfield(mode)" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
- "1=subfield(mode)" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
- #"2=unused"
- #"3=unused"
- "4=TRUNC"
- "5=reserved(CEXEC)" # close-on-exec
- "6=RCLOSE" # remove-on-close
- #"7=unused"
+ "bit 0=num(MODE)" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+ "bit 1=num(MODE)" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+ #"bit 2=unused"
+ #"bit 3=unused"
+ "bit 4=TRUNC"
+ "bit 5=reserved(CEXEC)" # close-on-exec
+ "bit 6=RCLOSE" # remove-on-close
+ #"bit 7=unused"
- "READ = 0" # make available for this FID: Tread()
- "WRITE = 1" # make available for this FID: Twrite()
- "RDWR = 2" # make available for this FID: Tread() and Twrite()
- "EXEC = 3" # make available for this FID: Tread()
+ "num(MODE) READ = 0" # make available for this FID: Tread()
+ "num(MODE) WRITE = 1" # make available for this FID: Twrite()
+ "num(MODE) RDWR = 2" # make available for this FID: Tread() and Twrite()
+ "num(MODE) EXEC = 3" # make available for this FID: Tread()
- "MODE_MASK = 0b00000011"
- "FLAG_MASK = 0b11111100"
+ "mask FLAG = 0b11111100"
# A 9P2000 session goes:
#
diff --git a/lib9p/idl/2005-9P2000.u.9p b/lib9p/idl/2005-9P2000.u.9p
index fefe3e9..6c2f2dc 100644
--- a/lib9p/idl/2005-9P2000.u.9p
+++ b/lib9p/idl/2005-9P2000.u.9p
@@ -12,7 +12,7 @@ from ./2002-9P2000.9p import *
# numeric user ID
num nuid = 4
- "NONUID = ~0"
+ "NONUID = u32_max"
num errno = 4
"NOERROR = 0"
@@ -27,10 +27,10 @@ msg Tattach += "n_uid[nuid]"
msg Rerror += "errno[errno]"
-bitfield dm += "23=DEVICE"
- "21=NAMEDPIPE"
- "20=SOCKET"
- "19=SETUID"
- "18=SETGID"
+bitfield dm += "bit 23=DEVICE"
+ "bit 21=PIPE"
+ "bit 20=SOCKET"
+ "bit 19=SETUID"
+ "bit 18=SETGID"
-bitfield qt += "1=SYMLINK"
+bitfield qt += "bit 1=SYMLINK"
diff --git a/lib9p/idl/2010-9P2000.L.9p b/lib9p/idl/2010-9P2000.L.9p
index 7ac86a6..d81a15b 100644
--- a/lib9p/idl/2010-9P2000.L.9p
+++ b/lib9p/idl/2010-9P2000.L.9p
@@ -39,49 +39,48 @@ num super_magic = 4
# protocol.h (and are different than the Linux kernel's values, which
# vary by architecture).
bitfield lo = 4
- "0=subfield(mode)" # low bit of the 2-bit RDONLY/WRONLY/RDWR/NOACCESS enum
- "1=subfield(mode)" # high bit of the 2-bit RDONLY/WRONLY/RDWR/NOACCESS enum
- #"2=unused"
- #"3=unused"
- #"4=unused"
- #"5=unused"
- "6=CREATE"
- "7=EXCL"
- "8=NOCTTY"
- "9=TRUNC"
- "10=APPEND"
- "11=NONBLOCK"
- "12=DSYNC"
- "13=BSD_FASYNC"
- "14=DIRECT"
- "15=LARGEFILE"
- "16=DIRECTORY"
- "17=NOFOLLOW"
- "18=NOATIME"
- "19=CLOEXEC"
- "20=SYNC"
-
- "RDONLY = 0"
- "WRONLY = 1"
- "RDWR = 2"
- "NOACCESS = 3"
-
- "MODE_MASK = 0b000000000000000000011"
- "FLAG_MASK = 0b111111111111111000000"
+ "bit 0=num(MODE)" # low bit of the 2-bit RDONLY/WRONLY/RDWR/NOACCESS enum
+ "bit 1=num(MODE)" # high bit of the 2-bit RDONLY/WRONLY/RDWR/NOACCESS enum
+ #"bit 2=unused"
+ #"bit 3=unused"
+ #"bit 4=unused"
+ #"bit 5=unused"
+ "bit 6=CREATE"
+ "bit 7=EXCL"
+ "bit 8=NOCTTY"
+ "bit 9=TRUNC"
+ "bit 10=APPEND"
+ "bit 11=NONBLOCK"
+ "bit 12=DSYNC"
+ "bit 13=BSD_FASYNC"
+ "bit 14=DIRECT"
+ "bit 15=LARGEFILE"
+ "bit 16=DIRECTORY"
+ "bit 17=NOFOLLOW"
+ "bit 18=NOATIME"
+ "bit 19=CLOEXEC"
+ "bit 20=SYNC"
+
+ "num(MODE) RDONLY = 0"
+ "num(MODE) WRONLY = 1"
+ "num(MODE) RDWR = 2"
+ "num(MODE) NOACCESS = 3"
+
+ "mask FLAG = 0b111111111111111000000"
# "D"irentry "T"ype
#
# These match the Linux kernel's values.
num dt = 1
- "UNKNOWN = 0"
- "NAMED_PIPE = 1"
- "CHAR_DEV = 2"
- "DIRECTORY = 4"
- "BLOCK_DEV = 6"
- "REGULAR = 8"
- "SYMLINK = 10"
- "SOCKET = 12"
- "WHITEOUT = 14"
+ "UNKNOWN = 0"
+ "PIPE = 1"
+ "CHAR_DEV = 2"
+ "DIRECTORY = 4"
+ "BLOCK_DEV = 6" # proof it's not a bitfield
+ "REGULAR = 8"
+ "SYMLINK = 10" # proof it's not a bitfield
+ "SOCKET = 12" # proof it's not a bitfield
+ "_WHITEOUT = 14" # proof it's not a bitfield
# Mode
#
@@ -89,34 +88,33 @@ num dt = 1
# instead of just 16? Who knows?
bitfield mode = 4
#...
- "15=subfield(fmt)" # bit of the 4-bit FMT_ enum
- "14=subfield(fmt)" # bit of the 4-bit FMT_ enum
- "13=subfield(fmt)" # bit of the 4-bit FMT_ enum
- "12=subfield(fmt)" # bit of the 4-bit FMT_ enum
+ "bit 15=num(FMT)" # bit of the 4-bit FMT_ enum
+ "bit 14=num(FMT)" # bit of the 4-bit FMT_ enum
+ "bit 13=num(FMT)" # bit of the 4-bit FMT_ enum
+ "bit 12=num(FMT)" # bit of the 4-bit FMT_ enum
#...
- "11=PERM_SETGROUP"
- "10=PERM_SETUSER"
- "9=PERM_STICKY"
- "8=PERM_OWNER_R"
- "7=PERM_OWNER_W"
- "6=PERM_OWNER_X"
- "5=PERM_GROUP_R"
- "4=PERM_GROUP_W"
- "3=PERM_GROUP_X"
- "2=PERM_OTHER_R"
- "1=PERM_OTHER_W"
- "0=PERM_OTHER_X"
-
- "FMT_NAMED_PIPE = LIB9P_DT_NAMED_PIPE<<12"
- "FMT_CHAR_DEV = LIB9P_DT_CHAR_DEV<<12"
- "FMT_DIRECTORY = LIB9P_DT_DIRECTORY<<12"
- "FMT_BLOCK_DEV = LIB9P_DT_BLOCK_DEV<<12"
- "FMT_REGULAR = LIB9P_DT_REGULAR<<12"
- "FMT_SYMLINK = LIB9P_DT_SYMLINK<<12"
- "FMT_SOCKET = LIB9P_DT_SOCKET<<12"
-
- "PERM_MASK = 0000777" # PERM_*
- "FMT_MASK = 0170000" # _fmt_*
+ "bit 11=PERM_SETGROUP"
+ "bit 10=PERM_SETUSER"
+ "bit 9=PERM_STICKY"
+ "bit 8=PERM_OWNER_R"
+ "bit 7=PERM_OWNER_W"
+ "bit 6=PERM_OWNER_X"
+ "bit 5=PERM_GROUP_R"
+ "bit 4=PERM_GROUP_W"
+ "bit 3=PERM_GROUP_X"
+ "bit 2=PERM_OTHER_R"
+ "bit 1=PERM_OTHER_W"
+ "bit 0=PERM_OTHER_X"
+
+ "num(FMT) PIPE = dt.PIPE<<12"
+ "num(FMT) CHAR_DEV = dt.CHAR_DEV<<12"
+ "num(FMT) DIRECTORY = dt.DIRECTORY<<12"
+ "num(FMT) BLOCK_DEV = dt.BLOCK_DEV<<12"
+ "num(FMT) REGULAR = dt.REGULAR<<12"
+ "num(FMT) SYMLINK = dt.SYMLINK<<12"
+ "num(FMT) SOCKET = dt.SOCKET<<12"
+
+ "mask PERM = 07777" # PERM_*
# A boolean value that is for some reason 4 bytes wide.
num b4 = 4
@@ -125,35 +123,35 @@ num b4 = 4
# all other values are true also
bitfield getattr = 8
- "0=MODE"
- "1=NLINK"
- "2=UID"
- "3=GID"
- "4=RDEV"
- "5=ATIME"
- "6=MTIME"
- "7=CTIME"
- "8=INO"
- "9=SIZE"
- "10=BLOCKS"
-
- "11=BTIME"
- "12=GEN"
- "13=DATA_VERSION"
-
- "BASIC=0x000007ff" # Mask for fields up to BLOCKS
- "ALL =0x00003fff" # Mask for All fields above
+ "bit 0=MODE"
+ "bit 1=NLINK"
+ "bit 2=UID"
+ "bit 3=GID"
+ "bit 4=RDEV"
+ "bit 5=ATIME"
+ "bit 6=MTIME"
+ "bit 7=CTIME"
+ "bit 8=INO"
+ "bit 9=SIZE"
+ "bit 10=BLOCKS"
+
+ "bit 11=BTIME"
+ "bit 12=GEN"
+ "bit 13=DATA_VERSION"
+
+ "alias BASIC=0x000007ff" # Mask for fields up to BLOCKS
+ "alias ALL =0x00003fff" # Mask for All fields above
bitfield setattr = 4
- "0=MODE"
- "1=UID"
- "2=GID"
- "3=SIZE"
- "4=ATIME"
- "5=MTIME"
- "6=CTIME"
- "7=ATIME_SET"
- "8=MTIME_SET"
+ "bit 0=MODE"
+ "bit 1=UID"
+ "bit 2=GID"
+ "bit 3=SIZE"
+ "bit 4=ATIME"
+ "bit 5=MTIME"
+ "bit 6=CTIME"
+ "bit 7=ATIME_SET"
+ "bit 8=MTIME_SET"
num lock_type = 1
"RDLCK=0"
@@ -161,8 +159,8 @@ num lock_type = 1
"UNLCK=2"
bitfield lock_flags = 4
- "0=BLOCK"
- "1=RECLAIM"
+ "bit 0=BLOCK"
+ "bit 1=RECLAIM"
num lock_status = 1
"SUCCESS=0"
diff --git a/lib9p/idl/__init__.py b/lib9p/idl/__init__.py
index e7b3670..2d09217 100644
--- a/lib9p/idl/__init__.py
+++ b/lib9p/idl/__init__.py
@@ -15,14 +15,27 @@ __all__ = [
# types
"Type",
"Primitive",
+ *["Expr", "ExprTok", "ExprOp", "ExprLit", "ExprSym", "ExprOff", "ExprNum"],
"Number",
- *["Bitfield", "Bit", "BitCat", "BitAlias"],
- *["Struct", "StructMember", "Expr", "ExprOp", "ExprSym", "ExprLit"],
+ *["Bitfield", "Bit", "BitCat", "BitNum", "BitAlias"],
+ *["Struct", "StructMember"],
"Message",
]
# The syntax that this parses is described in `./0000-README.md`.
+# Utilities ####################################################################
+
+
+def get_type(env: dict[str, "Type"], name: str, tc: type["T"]) -> "T":
+ if name not in env:
+ raise NameError(f"Unknown type {name!r}")
+ ret = env[name]
+ if (not isinstance(ret, tc)) or (ret.__class__.__name__ != tc.__name__):
+ raise NameError(f"Type {ret.typname!r} is not a {tc.__name__}")
+ return ret
+
+
# Types ########################################################################
@@ -51,13 +64,129 @@ class Primitive(enum.Enum):
return self.value
+class ExprOp:
+ op: typing.Literal["-", "+", "<<"]
+
+ def __init__(self, op: typing.Literal["-", "+", "<<"]) -> None:
+ self.op = op
+
+
+class ExprLit:
+ val: int
+
+ def __init__(self, val: int) -> None:
+ self.val = val
+
+
+class ExprSym:
+ symname: str
+
+ def __init__(self, name: str) -> None:
+ self.symname = name
+
+
+class ExprOff:
+ membname: str
+
+ def __init__(self, name: str) -> None:
+ self.membname = name
+
+
+class ExprNum:
+ numname: str
+ valname: str
+
+ def __init__(self, numname: str, valname: str) -> None:
+ self.numname = numname
+ self.valname = valname
+
+
+type ExprTok = ExprOp | ExprLit | ExprSym | ExprOff | ExprNum
+
+
+class Expr:
+ tokens: typing.Sequence[ExprTok]
+ const: int | None
+
+ def __init__(
+ self, env: dict[str, "Type"], tokens: typing.Sequence[ExprTok] = ()
+ ) -> None:
+ self.tokens = tokens
+ self.const = self._const(env, tokens)
+
+ def _const(
+ self, env: dict[str, "Type"], toks: typing.Sequence[ExprTok]
+ ) -> int | None:
+ if not toks:
+ return None
+
+ def read_val() -> int | None:
+ nonlocal toks
+ assert toks
+ neg = False
+ match toks[0]:
+ case ExprOp(op="-"):
+ neg = True
+ toks = toks[1:]
+ assert not isinstance(toks[0], ExprOp)
+ val: int
+ match toks[0]:
+ case ExprLit():
+ val = toks[0].val
+ case ExprSym():
+ if m := re.fullmatch(r"^u(8|16|32|64)_max$", toks[0].symname):
+ n = int(m.group(1))
+ val = (1 << n) - 1
+ elif m := re.fullmatch(r"^s(8|16|32|64)_max$", toks[0].symname):
+ n = int(m.group(1))
+ val = (1 << (n - 1)) - 1
+ else:
+ return None
+ case ExprOff():
+ return None
+ case ExprNum():
+ num = get_type(env, toks[0].numname, Number)
+ if toks[0].valname not in num.vals:
+ raise NameError(
+ f"Type {toks[0].numname!r} does not have a value {toks[0].valname!r}"
+ )
+ _val = num.vals[toks[0].valname].const
+ if _val is None:
+ return None
+ val = _val
+ toks = toks[1:]
+ return -val if neg else val
+
+ ret = read_val()
+ if ret is None:
+ return None
+ while toks:
+ assert isinstance(toks[0], ExprOp)
+ op = toks[0].op
+ toks = toks[1:]
+ operand = read_val()
+ if operand is None:
+ return None
+ match op:
+ case "+":
+ ret = ret + operand
+ case "-":
+ ret = ret - operand
+ case "<<":
+ ret = ret << operand
+ return ret
+
+ def __bool__(self) -> bool:
+ return len(self.tokens) > 0
+
+
class Number:
typname: str
in_versions: set[str]
prim: Primitive
- vals: dict[str, str]
+ vals: dict[str, Expr]
def __init__(self) -> None:
self.in_versions = set()
@@ -74,11 +203,31 @@ class Number:
return self.static_size
-class BitCat(enum.Enum):
- UNUSED = 1
- USED = 2
- RESERVED = 3
- SUBFIELD = 4
+class BitAlias:
+ bitname: str
+ in_versions: set[str]
+ val: Expr
+
+ def __init__(self, name: str, val: Expr) -> None:
+ if val.const is None:
+ raise ValueError(f"{name!r} value is not constant")
+ self.bitname = name
+ self.in_versions = set()
+ self.val = val
+
+
+class BitNum:
+ numname: str
+ mask: int
+ vals: dict[str, BitAlias]
+
+ def __init__(self, name: str) -> None:
+ self.numname = name
+ self.mask = 0
+ self.vals = {}
+
+
+type BitCat = typing.Literal["UNUSED", "USED", "RESERVED"] | BitNum
class Bit:
@@ -91,33 +240,32 @@ class Bit:
self.bitname = ""
self.in_versions = set()
self.num = num
- self.cat = BitCat.UNUSED
-
-
-class BitAlias:
- bitname: str
- in_versions: set[str]
- val: str # FIXME: Don't have bitfield aliases be raw C expressions
-
- def __init__(self, name: str, val: str) -> None:
- self.bitname = name
- self.in_versions = set()
- self.val = val
+ self.cat = "UNUSED"
class Bitfield:
typname: str
in_versions: set[str]
prim: Primitive
+
bits: list[Bit]
- names: dict[str, Bit | BitAlias]
+ nums: dict[str, BitNum]
+ masks: dict[str, BitAlias]
+ aliases: dict[str, BitAlias]
+
+ names: set[str]
def __init__(self, name: str, prim: Primitive) -> None:
self.typname = name
self.in_versions = set()
self.prim = prim
+
self.bits = [Bit(i) for i in range(prim.static_size * 8)]
- self.names = {}
+ self.nums = {}
+ self.masks = {}
+ self.aliases = {}
+
+ self.names = set()
@property
def static_size(self) -> int:
@@ -130,40 +278,9 @@ class Bitfield:
return self.static_size
-class ExprLit:
- val: int
-
- def __init__(self, val: int) -> None:
- self.val = val
-
-
-class ExprSym:
- symname: str
-
- def __init__(self, name: str) -> None:
- self.symname = name
-
-
-class ExprOp:
- op: typing.Literal["-", "+"]
-
- def __init__(self, op: typing.Literal["-", "+"]) -> None:
- self.op = op
-
-
-class Expr:
- tokens: list[ExprLit | ExprSym | ExprOp]
-
- def __init__(self) -> None:
- self.tokens = []
-
- def __bool__(self) -> bool:
- return len(self.tokens) > 0
-
-
class StructMember:
# from left-to-right when parsing
- cnt: "StructMember | None" = None
+ cnt: "StructMember| int | None" = None
membname: str
typ: "Type"
max: Expr
@@ -174,6 +291,8 @@ class StructMember:
@property
def min_cnt(self) -> int:
assert self.cnt
+ if isinstance(self.cnt, int):
+ return self.cnt
if not isinstance(self.cnt.typ, Primitive):
raise ValueError(
f"list count must be an integer type: {self.cnt.membname!r}"
@@ -185,6 +304,8 @@ class StructMember:
@property
def max_cnt(self) -> int:
assert self.cnt
+ if isinstance(self.cnt, int):
+ return self.cnt
if not isinstance(self.cnt.typ, Primitive):
raise ValueError(
f"list count must be an integer type: {self.cnt.membname!r}"
@@ -193,21 +314,12 @@ class StructMember:
raise ValueError(f"list count may not have ,val=: {self.cnt.membname!r}")
if self.cnt.max:
# TODO: be more flexible?
- if len(self.cnt.max.tokens) != 1:
+ val = self.cnt.max.const
+ if val is None:
raise ValueError(
- f"list count ,max= may only have 1 token: {self.cnt.membname!r}"
+ f"list count ,max= must be a constant value: {self.cnt.membname!r}"
)
- match tok := self.cnt.max.tokens[0]:
- case ExprLit():
- return tok.val
- case ExprSym(symname="s32_max"):
- return (1 << 31) - 1
- case ExprSym(symname="s64_max"):
- return (1 << 63) - 1
- case _:
- raise ValueError(
- f'list count ,max= only allows literal, "s32_max", and "s64_max" tokens: {self.cnt.membname!r}'
- )
+ return val
return (1 << (self.cnt.typ.value * 8)) - 1
@property
@@ -279,6 +391,8 @@ T = typing.TypeVar("T", Number, Bitfield, Struct, Message)
# Parse ########################################################################
+# common elements ######################
+
re_priname = "(?:1|2|4|8)" # primitive names
re_symname = "(?:[a-zA-Z_][a-zA-Z_0-9]*)" # "symbol" names; most *.9p-defined names
re_symname_u = "(?:[A-Z_][A-Z_0-9]*)" # upper-case "symbol" names; bit names
@@ -288,99 +402,186 @@ re_msgname = r"(?:[TR][a-zA-Z_0-9]*)" # names a message can be
re_memtype = f"(?:{re_symname}|{re_priname})" # typenames that a struct member can be
-re_expr = f"(?:(?:-|\\+|[0-9]+|&?{re_symname})+)"
+valid_syms = [
+ "end",
+ "u8_max",
+ "u16_max",
+ "u32_max",
+ "u64_max",
+ "s8_max",
+ "s16_max",
+ "s32_max",
+ "s64_max",
+]
-re_numspec = f"(?P<name>{re_symname})\\s*=\\s*(?P<val>\\S+)"
+_re_expr_op = r"(?:-|\+|<<)"
-re_bitspec_bit = (
- "(?P<bitnum>[0-9]+)\\s*=\\s*(?:"
+_res_expr_val = {
+ "lit_2": r"0b[01]+",
+ "lit_8": r"0[0-7]+",
+ "lit_10": r"0(?![0-9bxX])|[1-9][0-9]*",
+ "lit_16": r"0[xX][0-9a-fA-F]+",
+ "sym": "|".join(valid_syms), # pre-defined symbols
+ "off": f"&{re_symname}", # offset of a field this struct
+ "num": f"{re_symname}\\.{re_symname}", # `num` values
+}
+
+re_expr_tok = (
+ "(?:"
+ "|".join(
[
- f"(?P<name_used>{re_symname_u})",
- f"reserved\\((?P<name_reserved>{re_symname_u})\\)",
- f"subfield\\((?P<name_subfield>{re_symname_l})\\)",
+ f"(?P<op>{_re_expr_op})",
+ *[f"(?P<{k}>{v})" for k, v in _res_expr_val.items()],
]
)
+ ")"
)
-re_bitspec_alias = f"(?P<name>{re_symname_u})\\s*=\\s*(?P<val>\\S+)"
-re_memberspec = f"(?:(?P<cnt>{re_symname})\\*\\()?(?P<name>{re_symname})\\[(?P<typ>{re_memtype})(?:,max=(?P<max>{re_expr})|,val=(?P<val>{re_expr}))*\\]\\)?"
+_re_expr_val = "(?:" + "|".join(_res_expr_val.values()) + ")"
+re_expr = f"(?:\\s*(?:-\\s*)?{_re_expr_val}\\s*(?:{_re_expr_op}\\s*(?:-\\s*)?{_re_expr_val}\\s*)*)"
-def parse_numspec(ver: str, n: Number, spec: str) -> None:
+
+def parse_expr(env: dict[str, Type], expr: str) -> Expr:
+ assert re.fullmatch(re_expr, expr)
+ tokens: list[ExprTok] = []
+ for m in re.finditer(re_expr_tok, expr):
+ if tok := m.group("op"):
+ tokens.append(ExprOp(typing.cast(typing.Literal["-", "+", "<<"], tok)))
+ elif tok := m.group("lit_2"):
+ tokens.append(ExprLit(int(tok[2:], 2)))
+ elif tok := m.group("lit_8"):
+ tokens.append(ExprLit(int(tok[1:], 8)))
+ elif tok := m.group("lit_10"):
+ tokens.append(ExprLit(int(tok, 10)))
+ elif tok := m.group("lit_16"):
+ tokens.append(ExprLit(int(tok[2:], 16)))
+ elif tok := m.group("sym"):
+ tokens.append(ExprSym(tok))
+ elif tok := m.group("off"):
+ tokens.append(ExprOff(tok[1:]))
+ elif tok := m.group("num"):
+ [numname, valname] = tok.split(".", 1)
+ tokens.append(ExprNum(numname, valname))
+ else:
+ assert False
+ return Expr(env, tokens)
+
+
+# numspec ##############################
+
+re_numspec = f"(?P<name>{re_symname})\\s*=\\s*(?P<val>{re_expr})"
+
+
+def parse_numspec(env: dict[str, Type], ver: str, n: Number, spec: str) -> None:
spec = spec.strip()
if m := re.fullmatch(re_numspec, spec):
name = m.group("name")
- val = m.group("val")
if name in n.vals:
raise ValueError(f"{n.typname}: name {name!r} already assigned")
+ val = parse_expr(env, m.group("val"))
+ if val is None:
+ raise ValueError(
+ f"{n.typname}: {name!r} value is not constant: {m.group('val')!r}"
+ )
n.vals[name] = val
else:
raise SyntaxError(f"invalid num spec {spec!r}")
-def parse_bitspec(ver: str, bf: Bitfield, spec: str) -> None:
+# bitspec ##############################
+
+re_bitspec_bit = (
+ "bit\\s+(?P<bitnum>[0-9]+)\\s*=\\s*(?:"
+ + "|".join(
+ [
+ f"(?P<name_used>{re_symname_u})",
+ f"reserved\\((?P<name_reserved>{re_symname_u})\\)",
+ f"num\\((?P<name_num>{re_symname_u})\\)",
+ ]
+ )
+ + ")"
+)
+re_bitspec_mask = f"mask\\s+(?P<name>{re_symname_u})\\s*=\\s*(?P<val>{re_expr})"
+re_bitspec_alias = f"alias\\s+(?P<name>{re_symname_u})\\s*=\\s*(?P<val>{re_expr})"
+re_bitspec_num = f"num\\((?P<num>{re_symname_u})\\)\\s+(?P<name>{re_symname_u})\\s*=\\s*(?P<val>{re_expr})"
+
+
+def parse_bitspec(env: dict[str, Type], ver: str, bf: Bitfield, spec: str) -> None:
spec = spec.strip()
+ def check_name(name: str, is_num: bool = False) -> None:
+ if name == "MASK":
+ raise ValueError(f"{bf.typname}: bit name may not be {'MASK'!r}: {name!r}")
+ if name.endswith("_MASK"):
+ raise ValueError(
+ f"{bf.typname}: bit name may not end with {'_MASK'!r}: {name!r}"
+ )
+ if name in bf.names and not (is_num and name in bf.nums):
+ raise ValueError(f"{bf.typname}: bit name already assigned: {name!r}")
+
if m := re.fullmatch(re_bitspec_bit, spec):
bitnum = int(m.group("bitnum"))
if bitnum < 0 or bitnum >= len(bf.bits):
raise ValueError(f"{bf.typname}: bit num {bitnum} out-of-bounds")
bit = bf.bits[bitnum]
- if bit.cat != BitCat.UNUSED:
+ if bit.cat != "UNUSED":
raise ValueError(f"{bf.typname}: bit num {bitnum} already assigned")
if name := m.group("name_used"):
bit.bitname = name
- bit.cat = BitCat.USED
+ bit.cat = "USED"
bit.in_versions.add(ver)
elif name := m.group("name_reserved"):
bit.bitname = name
- bit.cat = BitCat.RESERVED
+ bit.cat = "RESERVED"
bit.in_versions.add(ver)
- elif name := m.group("name_subfield"):
+ elif name := m.group("name_num"):
bit.bitname = name
- bit.cat = BitCat.SUBFIELD
+ if name not in bf.nums:
+ bf.nums[name] = BitNum(name)
+ bf.nums[name].mask |= 1 << bit.num
+ bit.cat = bf.nums[name]
bit.in_versions.add(ver)
if bit.bitname:
- if bit.bitname in bf.names:
- other = bf.names[bit.bitname]
- if (
- isinstance(other, Bit)
- and other.cat == bit.cat
- and bit.cat == BitCat.SUBFIELD
- ):
- return
- raise ValueError(
- f"{bf.typname}: bit name {bit.bitname!r} already assigned"
- )
- bf.names[bit.bitname] = bit
+ check_name(name, isinstance(bit.cat, BitNum))
+ bf.names.add(bit.bitname)
+ elif m := re.fullmatch(re_bitspec_mask, spec):
+ mask = BitAlias(m.group("name"), parse_expr(env, m.group("val")))
+ mask.in_versions.add(ver)
+ check_name(mask.bitname)
+ bf.masks[mask.bitname] = mask
+ bf.names.add(mask.bitname)
elif m := re.fullmatch(re_bitspec_alias, spec):
- alias = BitAlias(m.group("name"), m.group("val"))
+ alias = BitAlias(m.group("name"), parse_expr(env, m.group("val")))
alias.in_versions.add(ver)
- if alias.bitname in bf.names:
+ check_name(alias.bitname)
+ bf.aliases[alias.bitname] = alias
+ bf.names.add(alias.bitname)
+ elif m := re.fullmatch(re_bitspec_num, spec):
+ numname = m.group("num")
+ alias = BitAlias(m.group("name"), parse_expr(env, m.group("val")))
+ alias.in_versions.add(ver)
+ check_name(alias.bitname)
+ if numname not in bf.nums:
+ raise NameError(
+ f"{bf.typname}: nested num not allocated any bits: {numname!r}"
+ )
+ assert alias.val.const is not None
+ if alias.val.const & ~bf.nums[numname].mask:
raise ValueError(
- f"{bf.typname}: bit name {alias.bitname!r} already assigned"
+ f"{bf.typname}: {alias.bitname!r} does not fit within bitmask: val={alias.val.const:b} mask={bf.nums[numname].mask}"
)
- bf.names[alias.bitname] = alias
+ bf.nums[numname].vals[alias.bitname] = alias
+ bf.names.add(alias.bitname)
else:
raise SyntaxError(f"invalid bitfield spec {spec!r}")
-def parse_expr(expr: str) -> Expr:
- assert re.fullmatch(re_expr, expr)
- ret = Expr()
- for tok in re.split("([-+])", expr):
- if tok in ("-", "+"):
- # I, for the life of me, do not understand why I need this
- # typing.cast() to keep mypy happy.
- ret.tokens += [ExprOp(typing.cast(typing.Literal["-", "+"], tok))]
- elif re.fullmatch("[0-9]+", tok):
- ret.tokens += [ExprLit(int(tok))]
- else:
- ret.tokens += [ExprSym(tok)]
- return ret
+# struct members #######################
+
+
+re_memberspec = f"(?:(?P<cnt>{re_symname}|[1-9][0-9]*)\\*\\()?(?P<name>{re_symname})\\[(?P<typ>{re_memtype})(?:,max=(?P<max>{re_expr})|,val=(?P<val>{re_expr}))*\\]\\)?"
def parse_members(ver: str, env: dict[str, Type], struct: Struct, specs: str) -> None:
@@ -401,29 +602,44 @@ def parse_members(ver: str, env: dict[str, Type], struct: Struct, specs: str) ->
member.typ = env[m.group("typ")]
if cnt := m.group("cnt"):
- if len(struct.members) == 0 or struct.members[-1].membname != cnt:
- raise ValueError(f"list count must be previous item: {cnt!r}")
- cnt_mem = struct.members[-1]
- member.cnt = cnt_mem
- _ = member.max_cnt # force validation
+ if cnt.isnumeric():
+ member.cnt = int(cnt)
+ else:
+ if len(struct.members) == 0 or struct.members[-1].membname != cnt:
+ raise ValueError(f"list count must be previous item: {cnt!r}")
+ member.cnt = struct.members[-1]
+ _ = member.max_cnt # force validation
if maxstr := m.group("max"):
- if (not isinstance(member.typ, Primitive)) or member.cnt:
- raise ValueError("',max=' may only be specified on a non-repeated atom")
- member.max = parse_expr(maxstr)
+ if (
+ not isinstance(member.typ, Primitive)
+ and not isinstance(member.typ, Number)
+ ) or member.cnt:
+ raise ValueError(
+ "',max=' may only be specified on a non-repeated numeric type"
+ )
+ member.max = parse_expr(env, maxstr)
else:
- member.max = Expr()
+ member.max = Expr(env)
if valstr := m.group("val"):
- if (not isinstance(member.typ, Primitive)) or member.cnt:
- raise ValueError("',val=' may only be specified on a non-repeated atom")
- member.val = parse_expr(valstr)
+ if (
+ not isinstance(member.typ, Primitive)
+ and not isinstance(member.typ, Number)
+ ) or member.cnt:
+ raise ValueError(
+ "',val=' may only be specified on a non-repeated numeric type"
+ )
+ member.val = parse_expr(env, valstr)
else:
- member.val = Expr()
+ member.val = Expr(env)
struct.members += [member]
+# main parser ##########################
+
+
def re_string(grpname: str) -> str:
return f'"(?P<{grpname}>[^"]*)"'
@@ -455,15 +671,6 @@ def parse_file(
"8": Primitive.u64,
}
- def get_type(name: str, tc: type[T]) -> T:
- nonlocal env
- if name not in env:
- raise NameError(f"Unknown type {name!r}")
- ret = env[name]
- if (not isinstance(ret, tc)) or (ret.__class__.__name__ != tc.__name__):
- raise NameError(f"Type {ret.typname!r} is not a {tc.__name__}")
- return ret
-
with open(filename, "r", encoding="utf-8") as fh:
prev: Type | None = None
for lineno, line in enumerate(fh):
@@ -494,12 +701,19 @@ def parse_file(
typ.in_versions.add(version)
case Bitfield():
typ.in_versions.add(version)
- for bit in typ.bits:
- if other_version in bit.in_versions:
- bit.in_versions.add(version)
- for val in typ.names.values():
- if other_version in val.in_versions:
- val.in_versions.add(version)
+ for bf_bit in typ.bits:
+ if other_version in bf_bit.in_versions:
+ bf_bit.in_versions.add(version)
+ for bf_num in typ.nums.values():
+ for bf_val in bf_num.vals.values():
+ if other_version in bf_val.in_versions:
+ bf_val.in_versions.add(version)
+ for bf_mask in typ.masks.values():
+ if other_version in bf_mask.in_versions:
+ bf_mask.in_versions.add(version)
+ for bf_alias in typ.aliases.values():
+ if other_version in bf_alias.in_versions:
+ bf_alias.in_versions.add(version)
case Struct(): # and Message()
typ.in_versions.add(version)
for member in typ.members:
@@ -539,8 +753,8 @@ def parse_file(
env[bf.typname] = bf
prev = bf
elif m := re.fullmatch(re_line_bitfield_, line):
- bf = get_type(m.group("name"), Bitfield)
- parse_bitspec(version, bf, m.group("member"))
+ bf = get_type(env, m.group("name"), Bitfield)
+ parse_bitspec(env, version, bf, m.group("member"))
prev = bf
elif m := re.fullmatch(re_line_struct, line):
@@ -559,7 +773,7 @@ def parse_file(
env[struct.typname] = struct
prev = struct
case "+=":
- struct = get_type(m.group("name"), Struct)
+ struct = get_type(env, m.group("name"), Struct)
parse_members(version, env, struct, m.group("members"))
prev = struct
@@ -577,16 +791,16 @@ def parse_file(
env[msg.typname] = msg
prev = msg
case "+=":
- msg = get_type(m.group("name"), Message)
+ msg = get_type(env, m.group("name"), Message)
parse_members(version, env, msg, m.group("members"))
prev = msg
elif m := re.fullmatch(re_line_cont, line):
match prev:
case Bitfield():
- parse_bitspec(version, prev, m.group("specs"))
+ parse_bitspec(env, version, prev, m.group("specs"))
case Number():
- parse_numspec(version, prev, m.group("specs"))
+ parse_numspec(env, version, prev, m.group("specs"))
case Struct(): # and Message()
parse_members(version, env, prev, m.group("specs"))
case _:
@@ -607,12 +821,6 @@ def parse_file(
typs: list[UserType] = [x for x in env.values() if not isinstance(x, Primitive)]
for typ in [typ for typ in typs if isinstance(typ, Struct)]:
- valid_syms = [
- "end",
- "s32_max",
- "s64_max",
- *["&" + m.membname for m in typ.members],
- ]
for member in typ.members:
if (
not isinstance(member.typ, Primitive)
@@ -622,9 +830,11 @@ def parse_file(
f"{typ.typname}.{member.membname}: type {member.typ.typname} does not exist in {member.in_versions.difference(member.typ.in_versions)}"
)
for tok in [*member.max.tokens, *member.val.tokens]:
- if isinstance(tok, ExprSym) and tok.symname not in valid_syms:
- raise ValueError(
- f"{typ.typname}.{member.membname}: invalid sym: {tok.symname}"
+ if isinstance(tok, ExprOff) and not any(
+ m.membname == tok.membname for m in typ.members
+ ):
+ raise NameError(
+ f"{typ.typname}.{member.membname}: invalid offset: &{tok.membname}"
)
return version, typs
diff --git a/lib9p/include/lib9p/9p.generated.h b/lib9p/include/lib9p/9p.generated.h
index 7a50537..203549f 100644
--- a/lib9p/include/lib9p/9p.generated.h
+++ b/lib9p/include/lib9p/9p.generated.h
@@ -159,11 +159,11 @@ enum lib9p_msg_type { /* uint8_t */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
/* size = 2 ; max_iov = 1 ; max_copy = 2 */
typedef uint16_t lib9p_tag_t;
-#define LIB9P_TAG_NOTAG ((lib9p_tag_t)UINT16_C(~0))
+#define LIB9P_TAG_NOTAG ((lib9p_tag_t)(UINT16_MAX))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_fid_t;
-#define LIB9P_FID_NOFID ((lib9p_fid_t)UINT32_C(~0))
+#define LIB9P_FID_NOFID ((lib9p_fid_t)(UINT32_MAX))
/* min_size = 2 ; exp_size = 29 ; max_size = 65,537 ; max_iov = 2 ; max_copy = 2 */
struct lib9p_s {
@@ -175,364 +175,367 @@ struct lib9p_s {
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_dm_t;
-
-#define LIB9P_DM_DIR ((lib9p_dm_t)(1<<31))
-#define LIB9P_DM_APPEND ((lib9p_dm_t)(1<<30))
-#define LIB9P_DM_EXCL ((lib9p_dm_t)(1<<29))
-#define _LIB9P_DM_RESERVED_PLAN9_MOUNT ((lib9p_dm_t)(1<<28))
-#define LIB9P_DM_AUTH ((lib9p_dm_t)(1<<27))
-#define LIB9P_DM_TMP ((lib9p_dm_t)(1<<26))
-/* unused ((lib9p_dm_t)(1<<25)) */
-/* unused ((lib9p_dm_t)(1<<24)) */
+/* bits */
+#define LIB9P_DM_DIR ((lib9p_dm_t)(UINT32_C(1)<<31))
+#define LIB9P_DM_APPEND ((lib9p_dm_t)(UINT32_C(1)<<30))
+#define LIB9P_DM_EXCL ((lib9p_dm_t)(UINT32_C(1)<<29))
+#define _LIB9P_DM_PLAN9_MOUNT ((lib9p_dm_t)(UINT32_C(1)<<28))
+#define LIB9P_DM_AUTH ((lib9p_dm_t)(UINT32_C(1)<<27))
+#define LIB9P_DM_TMP ((lib9p_dm_t)(UINT32_C(1)<<26))
+#define _LIB9P_DM_UNUSED_25 ((lib9p_dm_t)(UINT32_C(1)<<25))
+#define _LIB9P_DM_UNUSED_24 ((lib9p_dm_t)(UINT32_C(1)<<24))
#if CONFIG_9P_ENABLE_9P2000_u
-# define LIB9P_DM_DEVICE ((lib9p_dm_t)(1<<23))
+# define LIB9P_DM_DEVICE ((lib9p_dm_t)(UINT32_C(1)<<23))
#endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused ((lib9p_dm_t)(1<<22)) */
+#define _LIB9P_DM_UNUSED_22 ((lib9p_dm_t)(UINT32_C(1)<<22))
#if CONFIG_9P_ENABLE_9P2000_u
-# define LIB9P_DM_NAMEDPIPE ((lib9p_dm_t)(1<<21))
-# define LIB9P_DM_SOCKET ((lib9p_dm_t)(1<<20))
-# define LIB9P_DM_SETUID ((lib9p_dm_t)(1<<19))
-# define LIB9P_DM_SETGID ((lib9p_dm_t)(1<<18))
+# define LIB9P_DM_PIPE ((lib9p_dm_t)(UINT32_C(1)<<21))
+# define LIB9P_DM_SOCKET ((lib9p_dm_t)(UINT32_C(1)<<20))
+# define LIB9P_DM_SETUID ((lib9p_dm_t)(UINT32_C(1)<<19))
+# define LIB9P_DM_SETGID ((lib9p_dm_t)(UINT32_C(1)<<18))
#endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused ((lib9p_dm_t)(1<<17)) */
-/* unused ((lib9p_dm_t)(1<<16)) */
-/* unused ((lib9p_dm_t)(1<<15)) */
-/* unused ((lib9p_dm_t)(1<<14)) */
-/* unused ((lib9p_dm_t)(1<<13)) */
-/* unused ((lib9p_dm_t)(1<<12)) */
-/* unused ((lib9p_dm_t)(1<<11)) */
-/* unused ((lib9p_dm_t)(1<<10)) */
-/* unused ((lib9p_dm_t)(1<<9)) */
-#define LIB9P_DM_OWNER_R ((lib9p_dm_t)(1<<8))
-#define LIB9P_DM_OWNER_W ((lib9p_dm_t)(1<<7))
-#define LIB9P_DM_OWNER_X ((lib9p_dm_t)(1<<6))
-#define LIB9P_DM_GROUP_R ((lib9p_dm_t)(1<<5))
-#define LIB9P_DM_GROUP_W ((lib9p_dm_t)(1<<4))
-#define LIB9P_DM_GROUP_X ((lib9p_dm_t)(1<<3))
-#define LIB9P_DM_OTHER_R ((lib9p_dm_t)(1<<2))
-#define LIB9P_DM_OTHER_W ((lib9p_dm_t)(1<<1))
-#define LIB9P_DM_OTHER_X ((lib9p_dm_t)(1<<0))
-
-#define LIB9P_DM_PERM_MASK ((lib9p_dm_t)(0777))
+#define _LIB9P_DM_UNUSED_17 ((lib9p_dm_t)(UINT32_C(1)<<17))
+#define _LIB9P_DM_UNUSED_16 ((lib9p_dm_t)(UINT32_C(1)<<16))
+#define _LIB9P_DM_UNUSED_15 ((lib9p_dm_t)(UINT32_C(1)<<15))
+#define _LIB9P_DM_UNUSED_14 ((lib9p_dm_t)(UINT32_C(1)<<14))
+#define _LIB9P_DM_UNUSED_13 ((lib9p_dm_t)(UINT32_C(1)<<13))
+#define _LIB9P_DM_UNUSED_12 ((lib9p_dm_t)(UINT32_C(1)<<12))
+#define _LIB9P_DM_UNUSED_11 ((lib9p_dm_t)(UINT32_C(1)<<11))
+#define _LIB9P_DM_UNUSED_10 ((lib9p_dm_t)(UINT32_C(1)<<10))
+#define _LIB9P_DM_UNUSED_9 ((lib9p_dm_t)(UINT32_C(1)<<9))
+#define LIB9P_DM_OWNER_R ((lib9p_dm_t)(UINT32_C(1)<<8))
+#define LIB9P_DM_OWNER_W ((lib9p_dm_t)(UINT32_C(1)<<7))
+#define LIB9P_DM_OWNER_X ((lib9p_dm_t)(UINT32_C(1)<<6))
+#define LIB9P_DM_GROUP_R ((lib9p_dm_t)(UINT32_C(1)<<5))
+#define LIB9P_DM_GROUP_W ((lib9p_dm_t)(UINT32_C(1)<<4))
+#define LIB9P_DM_GROUP_X ((lib9p_dm_t)(UINT32_C(1)<<3))
+#define LIB9P_DM_OTHER_R ((lib9p_dm_t)(UINT32_C(1)<<2))
+#define LIB9P_DM_OTHER_W ((lib9p_dm_t)(UINT32_C(1)<<1))
+#define LIB9P_DM_OTHER_X ((lib9p_dm_t)(UINT32_C(1)<<0))
+/* masks */
+#define LIB9P_DM_PERM_MASK ((lib9p_dm_t)(0b000000000000000000000111111111))
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
/* size = 1 ; max_iov = 1 ; max_copy = 1 */
typedef uint8_t lib9p_qt_t;
-
-#define LIB9P_QT_DIR ((lib9p_qt_t)(1<<7))
-#define LIB9P_QT_APPEND ((lib9p_qt_t)(1<<6))
-#define LIB9P_QT_EXCL ((lib9p_qt_t)(1<<5))
-#define _LIB9P_QT_RESERVED_PLAN9_MOUNT ((lib9p_qt_t)(1<<4))
-#define LIB9P_QT_AUTH ((lib9p_qt_t)(1<<3))
-#define LIB9P_QT_TMP ((lib9p_qt_t)(1<<2))
+/* bits */
+#define LIB9P_QT_DIR ((lib9p_qt_t)(UINT8_C(1)<<7))
+#define LIB9P_QT_APPEND ((lib9p_qt_t)(UINT8_C(1)<<6))
+#define LIB9P_QT_EXCL ((lib9p_qt_t)(UINT8_C(1)<<5))
+#define _LIB9P_QT_PLAN9_MOUNT ((lib9p_qt_t)(UINT8_C(1)<<4))
+#define LIB9P_QT_AUTH ((lib9p_qt_t)(UINT8_C(1)<<3))
+#define LIB9P_QT_TMP ((lib9p_qt_t)(UINT8_C(1)<<2))
#if CONFIG_9P_ENABLE_9P2000_u
-# define LIB9P_QT_SYMLINK ((lib9p_qt_t)(1<<1))
+# define LIB9P_QT_SYMLINK ((lib9p_qt_t)(UINT8_C(1)<<1))
#endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused ((lib9p_qt_t)(1<<0)) */
-
-#define LIB9P_QT_FILE ((lib9p_qt_t)(0))
+#define _LIB9P_QT_UNUSED_0 ((lib9p_qt_t)(UINT8_C(1)<<0))
+/* aliases */
+#define LIB9P_QT_FILE ((lib9p_qt_t)(0))
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_nuid_t;
-#define LIB9P_NUID_NONUID ((lib9p_nuid_t)UINT32_C(~0))
+#define LIB9P_NUID_NONUID ((lib9p_nuid_t)(UINT32_MAX))
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
/* size = 1 ; max_iov = 1 ; max_copy = 1 */
typedef uint8_t lib9p_o_t;
-
-/* unused ((lib9p_o_t)(1<<7)) */
-#define LIB9P_O_RCLOSE ((lib9p_o_t)(1<<6))
-#define _LIB9P_O_RESERVED_CEXEC ((lib9p_o_t)(1<<5))
-#define LIB9P_O_TRUNC ((lib9p_o_t)(1<<4))
-/* unused ((lib9p_o_t)(1<<3)) */
-/* unused ((lib9p_o_t)(1<<2)) */
-#define _LIB9P_O_mode_1 ((lib9p_o_t)(1<<1))
-#define _LIB9P_O_mode_0 ((lib9p_o_t)(1<<0))
-
-#define LIB9P_O_READ ((lib9p_o_t)(0))
-#define LIB9P_O_WRITE ((lib9p_o_t)(1))
-#define LIB9P_O_RDWR ((lib9p_o_t)(2))
-#define LIB9P_O_EXEC ((lib9p_o_t)(3))
-#define LIB9P_O_MODE_MASK ((lib9p_o_t)(0b00000011))
+/* bits */
+#define _LIB9P_O_UNUSED_7 ((lib9p_o_t)(UINT8_C(1)<<7))
+#define LIB9P_O_RCLOSE ((lib9p_o_t)(UINT8_C(1)<<6))
+#define _LIB9P_O_RESERVED_CEXEC ((lib9p_o_t)(UINT8_C(1)<<5))
+#define LIB9P_O_TRUNC ((lib9p_o_t)(UINT8_C(1)<<4))
+#define _LIB9P_O_UNUSED_3 ((lib9p_o_t)(UINT8_C(1)<<3))
+#define _LIB9P_O_UNUSED_2 ((lib9p_o_t)(UINT8_C(1)<<2))
+/* number LIB9P_O_MODE_* ((lib9p_o_t)(UINT8_C(1)<<1)) */
+/* number LIB9P_O_MODE_* ((lib9p_o_t)(UINT8_C(1)<<0)) */
+/* masks */
#define LIB9P_O_FLAG_MASK ((lib9p_o_t)(0b11111100))
+/* number: MODE */
+#define LIB9P_O_MODE_READ ((lib9p_o_t)(0))
+#define LIB9P_O_MODE_WRITE ((lib9p_o_t)(1))
+#define LIB9P_O_MODE_RDWR ((lib9p_o_t)(2))
+#define LIB9P_O_MODE_EXEC ((lib9p_o_t)(3))
+#define LIB9P_O_MODE_MASK ((lib9p_o_t)(0b000011))
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_errno_t;
-#define LIB9P_ERRNO_NOERROR ((lib9p_errno_t)UINT32_C(0))
+#define LIB9P_ERRNO_NOERROR ((lib9p_errno_t)(0))
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_L
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_super_magic_t;
-#define LIB9P_SUPER_MAGIC_V9FS_MAGIC ((lib9p_super_magic_t)UINT32_C(0x01021997))
+#define LIB9P_SUPER_MAGIC_V9FS_MAGIC ((lib9p_super_magic_t)(16914839))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_lo_t;
-
-/* unused ((lib9p_lo_t)(1<<31)) */
-/* unused ((lib9p_lo_t)(1<<30)) */
-/* unused ((lib9p_lo_t)(1<<29)) */
-/* unused ((lib9p_lo_t)(1<<28)) */
-/* unused ((lib9p_lo_t)(1<<27)) */
-/* unused ((lib9p_lo_t)(1<<26)) */
-/* unused ((lib9p_lo_t)(1<<25)) */
-/* unused ((lib9p_lo_t)(1<<24)) */
-/* unused ((lib9p_lo_t)(1<<23)) */
-/* unused ((lib9p_lo_t)(1<<22)) */
-/* unused ((lib9p_lo_t)(1<<21)) */
-#define LIB9P_LO_SYNC ((lib9p_lo_t)(1<<20))
-#define LIB9P_LO_CLOEXEC ((lib9p_lo_t)(1<<19))
-#define LIB9P_LO_NOATIME ((lib9p_lo_t)(1<<18))
-#define LIB9P_LO_NOFOLLOW ((lib9p_lo_t)(1<<17))
-#define LIB9P_LO_DIRECTORY ((lib9p_lo_t)(1<<16))
-#define LIB9P_LO_LARGEFILE ((lib9p_lo_t)(1<<15))
-#define LIB9P_LO_DIRECT ((lib9p_lo_t)(1<<14))
-#define LIB9P_LO_BSD_FASYNC ((lib9p_lo_t)(1<<13))
-#define LIB9P_LO_DSYNC ((lib9p_lo_t)(1<<12))
-#define LIB9P_LO_NONBLOCK ((lib9p_lo_t)(1<<11))
-#define LIB9P_LO_APPEND ((lib9p_lo_t)(1<<10))
-#define LIB9P_LO_TRUNC ((lib9p_lo_t)(1<<9))
-#define LIB9P_LO_NOCTTY ((lib9p_lo_t)(1<<8))
-#define LIB9P_LO_EXCL ((lib9p_lo_t)(1<<7))
-#define LIB9P_LO_CREATE ((lib9p_lo_t)(1<<6))
-/* unused ((lib9p_lo_t)(1<<5)) */
-/* unused ((lib9p_lo_t)(1<<4)) */
-/* unused ((lib9p_lo_t)(1<<3)) */
-/* unused ((lib9p_lo_t)(1<<2)) */
-#define _LIB9P_LO_mode_1 ((lib9p_lo_t)(1<<1))
-#define _LIB9P_LO_mode_0 ((lib9p_lo_t)(1<<0))
-
-#define LIB9P_LO_RDONLY ((lib9p_lo_t)(0))
-#define LIB9P_LO_WRONLY ((lib9p_lo_t)(1))
-#define LIB9P_LO_RDWR ((lib9p_lo_t)(2))
-#define LIB9P_LO_NOACCESS ((lib9p_lo_t)(3))
-#define LIB9P_LO_MODE_MASK ((lib9p_lo_t)(0b000000000000000000011))
-#define LIB9P_LO_FLAG_MASK ((lib9p_lo_t)(0b111111111111111000000))
+/* bits */
+#define _LIB9P_LO_UNUSED_31 ((lib9p_lo_t)(UINT32_C(1)<<31))
+#define _LIB9P_LO_UNUSED_30 ((lib9p_lo_t)(UINT32_C(1)<<30))
+#define _LIB9P_LO_UNUSED_29 ((lib9p_lo_t)(UINT32_C(1)<<29))
+#define _LIB9P_LO_UNUSED_28 ((lib9p_lo_t)(UINT32_C(1)<<28))
+#define _LIB9P_LO_UNUSED_27 ((lib9p_lo_t)(UINT32_C(1)<<27))
+#define _LIB9P_LO_UNUSED_26 ((lib9p_lo_t)(UINT32_C(1)<<26))
+#define _LIB9P_LO_UNUSED_25 ((lib9p_lo_t)(UINT32_C(1)<<25))
+#define _LIB9P_LO_UNUSED_24 ((lib9p_lo_t)(UINT32_C(1)<<24))
+#define _LIB9P_LO_UNUSED_23 ((lib9p_lo_t)(UINT32_C(1)<<23))
+#define _LIB9P_LO_UNUSED_22 ((lib9p_lo_t)(UINT32_C(1)<<22))
+#define _LIB9P_LO_UNUSED_21 ((lib9p_lo_t)(UINT32_C(1)<<21))
+#define LIB9P_LO_SYNC ((lib9p_lo_t)(UINT32_C(1)<<20))
+#define LIB9P_LO_CLOEXEC ((lib9p_lo_t)(UINT32_C(1)<<19))
+#define LIB9P_LO_NOATIME ((lib9p_lo_t)(UINT32_C(1)<<18))
+#define LIB9P_LO_NOFOLLOW ((lib9p_lo_t)(UINT32_C(1)<<17))
+#define LIB9P_LO_DIRECTORY ((lib9p_lo_t)(UINT32_C(1)<<16))
+#define LIB9P_LO_LARGEFILE ((lib9p_lo_t)(UINT32_C(1)<<15))
+#define LIB9P_LO_DIRECT ((lib9p_lo_t)(UINT32_C(1)<<14))
+#define LIB9P_LO_BSD_FASYNC ((lib9p_lo_t)(UINT32_C(1)<<13))
+#define LIB9P_LO_DSYNC ((lib9p_lo_t)(UINT32_C(1)<<12))
+#define LIB9P_LO_NONBLOCK ((lib9p_lo_t)(UINT32_C(1)<<11))
+#define LIB9P_LO_APPEND ((lib9p_lo_t)(UINT32_C(1)<<10))
+#define LIB9P_LO_TRUNC ((lib9p_lo_t)(UINT32_C(1)<<9))
+#define LIB9P_LO_NOCTTY ((lib9p_lo_t)(UINT32_C(1)<<8))
+#define LIB9P_LO_EXCL ((lib9p_lo_t)(UINT32_C(1)<<7))
+#define LIB9P_LO_CREATE ((lib9p_lo_t)(UINT32_C(1)<<6))
+#define _LIB9P_LO_UNUSED_5 ((lib9p_lo_t)(UINT32_C(1)<<5))
+#define _LIB9P_LO_UNUSED_4 ((lib9p_lo_t)(UINT32_C(1)<<4))
+#define _LIB9P_LO_UNUSED_3 ((lib9p_lo_t)(UINT32_C(1)<<3))
+#define _LIB9P_LO_UNUSED_2 ((lib9p_lo_t)(UINT32_C(1)<<2))
+/* number LIB9P_LO_MODE_* ((lib9p_lo_t)(UINT32_C(1)<<1)) */
+/* number LIB9P_LO_MODE_* ((lib9p_lo_t)(UINT32_C(1)<<0)) */
+/* masks */
+#define LIB9P_LO_FLAG_MASK ((lib9p_lo_t)(0b000000000111111111111111000000))
+/* number: MODE */
+#define LIB9P_LO_MODE_RDONLY ((lib9p_lo_t)(0))
+#define LIB9P_LO_MODE_WRONLY ((lib9p_lo_t)(1))
+#define LIB9P_LO_MODE_RDWR ((lib9p_lo_t)(2))
+#define LIB9P_LO_MODE_NOACCESS ((lib9p_lo_t)(3))
+#define LIB9P_LO_MODE_MASK ((lib9p_lo_t)(0b000000000000000000000000000011))
/* size = 1 ; max_iov = 1 ; max_copy = 1 */
typedef uint8_t lib9p_dt_t;
-#define LIB9P_DT_UNKNOWN ((lib9p_dt_t)UINT8_C(0))
-#define LIB9P_DT_NAMED_PIPE ((lib9p_dt_t)UINT8_C(1))
-#define LIB9P_DT_CHAR_DEV ((lib9p_dt_t)UINT8_C(2))
-#define LIB9P_DT_DIRECTORY ((lib9p_dt_t)UINT8_C(4))
-#define LIB9P_DT_BLOCK_DEV ((lib9p_dt_t)UINT8_C(6))
-#define LIB9P_DT_REGULAR ((lib9p_dt_t)UINT8_C(8))
-#define LIB9P_DT_SYMLINK ((lib9p_dt_t)UINT8_C(10))
-#define LIB9P_DT_SOCKET ((lib9p_dt_t)UINT8_C(12))
-#define LIB9P_DT_WHITEOUT ((lib9p_dt_t)UINT8_C(14))
+#define LIB9P_DT_UNKNOWN ((lib9p_dt_t)(0))
+#define LIB9P_DT_PIPE ((lib9p_dt_t)(1))
+#define LIB9P_DT_CHAR_DEV ((lib9p_dt_t)(2))
+#define LIB9P_DT_DIRECTORY ((lib9p_dt_t)(4))
+#define LIB9P_DT_BLOCK_DEV ((lib9p_dt_t)(6))
+#define LIB9P_DT_REGULAR ((lib9p_dt_t)(8))
+#define LIB9P_DT_SYMLINK ((lib9p_dt_t)(10))
+#define LIB9P_DT_SOCKET ((lib9p_dt_t)(12))
+#define _LIB9P_DT_WHITEOUT ((lib9p_dt_t)(14))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_mode_t;
-
-/* unused ((lib9p_mode_t)(1<<31)) */
-/* unused ((lib9p_mode_t)(1<<30)) */
-/* unused ((lib9p_mode_t)(1<<29)) */
-/* unused ((lib9p_mode_t)(1<<28)) */
-/* unused ((lib9p_mode_t)(1<<27)) */
-/* unused ((lib9p_mode_t)(1<<26)) */
-/* unused ((lib9p_mode_t)(1<<25)) */
-/* unused ((lib9p_mode_t)(1<<24)) */
-/* unused ((lib9p_mode_t)(1<<23)) */
-/* unused ((lib9p_mode_t)(1<<22)) */
-/* unused ((lib9p_mode_t)(1<<21)) */
-/* unused ((lib9p_mode_t)(1<<20)) */
-/* unused ((lib9p_mode_t)(1<<19)) */
-/* unused ((lib9p_mode_t)(1<<18)) */
-/* unused ((lib9p_mode_t)(1<<17)) */
-/* unused ((lib9p_mode_t)(1<<16)) */
-#define _LIB9P_MODE_fmt_3 ((lib9p_mode_t)(1<<15))
-#define _LIB9P_MODE_fmt_2 ((lib9p_mode_t)(1<<14))
-#define _LIB9P_MODE_fmt_1 ((lib9p_mode_t)(1<<13))
-#define _LIB9P_MODE_fmt_0 ((lib9p_mode_t)(1<<12))
-#define LIB9P_MODE_PERM_SETGROUP ((lib9p_mode_t)(1<<11))
-#define LIB9P_MODE_PERM_SETUSER ((lib9p_mode_t)(1<<10))
-#define LIB9P_MODE_PERM_STICKY ((lib9p_mode_t)(1<<9))
-#define LIB9P_MODE_PERM_OWNER_R ((lib9p_mode_t)(1<<8))
-#define LIB9P_MODE_PERM_OWNER_W ((lib9p_mode_t)(1<<7))
-#define LIB9P_MODE_PERM_OWNER_X ((lib9p_mode_t)(1<<6))
-#define LIB9P_MODE_PERM_GROUP_R ((lib9p_mode_t)(1<<5))
-#define LIB9P_MODE_PERM_GROUP_W ((lib9p_mode_t)(1<<4))
-#define LIB9P_MODE_PERM_GROUP_X ((lib9p_mode_t)(1<<3))
-#define LIB9P_MODE_PERM_OTHER_R ((lib9p_mode_t)(1<<2))
-#define LIB9P_MODE_PERM_OTHER_W ((lib9p_mode_t)(1<<1))
-#define LIB9P_MODE_PERM_OTHER_X ((lib9p_mode_t)(1<<0))
-
-#define LIB9P_MODE_FMT_NAMED_PIPE ((lib9p_mode_t)(LIB9P_DT_NAMED_PIPE<<12))
-#define LIB9P_MODE_FMT_CHAR_DEV ((lib9p_mode_t)(LIB9P_DT_CHAR_DEV<<12))
-#define LIB9P_MODE_FMT_DIRECTORY ((lib9p_mode_t)(LIB9P_DT_DIRECTORY<<12))
-#define LIB9P_MODE_FMT_BLOCK_DEV ((lib9p_mode_t)(LIB9P_DT_BLOCK_DEV<<12))
-#define LIB9P_MODE_FMT_REGULAR ((lib9p_mode_t)(LIB9P_DT_REGULAR<<12))
-#define LIB9P_MODE_FMT_SYMLINK ((lib9p_mode_t)(LIB9P_DT_SYMLINK<<12))
-#define LIB9P_MODE_FMT_SOCKET ((lib9p_mode_t)(LIB9P_DT_SOCKET<<12))
-#define LIB9P_MODE_PERM_MASK ((lib9p_mode_t)(0000777))
-#define LIB9P_MODE_FMT_MASK ((lib9p_mode_t)(0170000))
+/* bits */
+#define _LIB9P_MODE_UNUSED_31 ((lib9p_mode_t)(UINT32_C(1)<<31))
+#define _LIB9P_MODE_UNUSED_30 ((lib9p_mode_t)(UINT32_C(1)<<30))
+#define _LIB9P_MODE_UNUSED_29 ((lib9p_mode_t)(UINT32_C(1)<<29))
+#define _LIB9P_MODE_UNUSED_28 ((lib9p_mode_t)(UINT32_C(1)<<28))
+#define _LIB9P_MODE_UNUSED_27 ((lib9p_mode_t)(UINT32_C(1)<<27))
+#define _LIB9P_MODE_UNUSED_26 ((lib9p_mode_t)(UINT32_C(1)<<26))
+#define _LIB9P_MODE_UNUSED_25 ((lib9p_mode_t)(UINT32_C(1)<<25))
+#define _LIB9P_MODE_UNUSED_24 ((lib9p_mode_t)(UINT32_C(1)<<24))
+#define _LIB9P_MODE_UNUSED_23 ((lib9p_mode_t)(UINT32_C(1)<<23))
+#define _LIB9P_MODE_UNUSED_22 ((lib9p_mode_t)(UINT32_C(1)<<22))
+#define _LIB9P_MODE_UNUSED_21 ((lib9p_mode_t)(UINT32_C(1)<<21))
+#define _LIB9P_MODE_UNUSED_20 ((lib9p_mode_t)(UINT32_C(1)<<20))
+#define _LIB9P_MODE_UNUSED_19 ((lib9p_mode_t)(UINT32_C(1)<<19))
+#define _LIB9P_MODE_UNUSED_18 ((lib9p_mode_t)(UINT32_C(1)<<18))
+#define _LIB9P_MODE_UNUSED_17 ((lib9p_mode_t)(UINT32_C(1)<<17))
+#define _LIB9P_MODE_UNUSED_16 ((lib9p_mode_t)(UINT32_C(1)<<16))
+/* number LIB9P_MODE_FMT_* ((lib9p_mode_t)(UINT32_C(1)<<15)) */
+/* number LIB9P_MODE_FMT_* ((lib9p_mode_t)(UINT32_C(1)<<14)) */
+/* number LIB9P_MODE_FMT_* ((lib9p_mode_t)(UINT32_C(1)<<13)) */
+/* number LIB9P_MODE_FMT_* ((lib9p_mode_t)(UINT32_C(1)<<12)) */
+#define LIB9P_MODE_PERM_SETGROUP ((lib9p_mode_t)(UINT32_C(1)<<11))
+#define LIB9P_MODE_PERM_SETUSER ((lib9p_mode_t)(UINT32_C(1)<<10))
+#define LIB9P_MODE_PERM_STICKY ((lib9p_mode_t)(UINT32_C(1)<<9))
+#define LIB9P_MODE_PERM_OWNER_R ((lib9p_mode_t)(UINT32_C(1)<<8))
+#define LIB9P_MODE_PERM_OWNER_W ((lib9p_mode_t)(UINT32_C(1)<<7))
+#define LIB9P_MODE_PERM_OWNER_X ((lib9p_mode_t)(UINT32_C(1)<<6))
+#define LIB9P_MODE_PERM_GROUP_R ((lib9p_mode_t)(UINT32_C(1)<<5))
+#define LIB9P_MODE_PERM_GROUP_W ((lib9p_mode_t)(UINT32_C(1)<<4))
+#define LIB9P_MODE_PERM_GROUP_X ((lib9p_mode_t)(UINT32_C(1)<<3))
+#define LIB9P_MODE_PERM_OTHER_R ((lib9p_mode_t)(UINT32_C(1)<<2))
+#define LIB9P_MODE_PERM_OTHER_W ((lib9p_mode_t)(UINT32_C(1)<<1))
+#define LIB9P_MODE_PERM_OTHER_X ((lib9p_mode_t)(UINT32_C(1)<<0))
+/* masks */
+#define LIB9P_MODE_PERM_MASK ((lib9p_mode_t)(0b000000000000000000111111111111))
+/* number: FMT */
+#define LIB9P_MODE_FMT_PIPE ((lib9p_mode_t)(LIB9P_DT_PIPE << 12))
+#define LIB9P_MODE_FMT_CHAR_DEV ((lib9p_mode_t)(LIB9P_DT_CHAR_DEV << 12))
+#define LIB9P_MODE_FMT_DIRECTORY ((lib9p_mode_t)(LIB9P_DT_DIRECTORY << 12))
+#define LIB9P_MODE_FMT_BLOCK_DEV ((lib9p_mode_t)(LIB9P_DT_BLOCK_DEV << 12))
+#define LIB9P_MODE_FMT_REGULAR ((lib9p_mode_t)(LIB9P_DT_REGULAR << 12))
+#define LIB9P_MODE_FMT_SYMLINK ((lib9p_mode_t)(LIB9P_DT_SYMLINK << 12))
+#define LIB9P_MODE_FMT_SOCKET ((lib9p_mode_t)(LIB9P_DT_SOCKET << 12))
+#define LIB9P_MODE_FMT_MASK ((lib9p_mode_t)(0b000000000000001111000000000000))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_b4_t;
-#define LIB9P_B4_FALSE ((lib9p_b4_t)UINT32_C(0))
-#define LIB9P_B4_TRUE ((lib9p_b4_t)UINT32_C(1))
+#define LIB9P_B4_FALSE ((lib9p_b4_t)(0))
+#define LIB9P_B4_TRUE ((lib9p_b4_t)(1))
/* size = 8 ; max_iov = 1 ; max_copy = 8 */
typedef uint64_t lib9p_getattr_t;
-
-/* unused ((lib9p_getattr_t)(1<<63)) */
-/* unused ((lib9p_getattr_t)(1<<62)) */
-/* unused ((lib9p_getattr_t)(1<<61)) */
-/* unused ((lib9p_getattr_t)(1<<60)) */
-/* unused ((lib9p_getattr_t)(1<<59)) */
-/* unused ((lib9p_getattr_t)(1<<58)) */
-/* unused ((lib9p_getattr_t)(1<<57)) */
-/* unused ((lib9p_getattr_t)(1<<56)) */
-/* unused ((lib9p_getattr_t)(1<<55)) */
-/* unused ((lib9p_getattr_t)(1<<54)) */
-/* unused ((lib9p_getattr_t)(1<<53)) */
-/* unused ((lib9p_getattr_t)(1<<52)) */
-/* unused ((lib9p_getattr_t)(1<<51)) */
-/* unused ((lib9p_getattr_t)(1<<50)) */
-/* unused ((lib9p_getattr_t)(1<<49)) */
-/* unused ((lib9p_getattr_t)(1<<48)) */
-/* unused ((lib9p_getattr_t)(1<<47)) */
-/* unused ((lib9p_getattr_t)(1<<46)) */
-/* unused ((lib9p_getattr_t)(1<<45)) */
-/* unused ((lib9p_getattr_t)(1<<44)) */
-/* unused ((lib9p_getattr_t)(1<<43)) */
-/* unused ((lib9p_getattr_t)(1<<42)) */
-/* unused ((lib9p_getattr_t)(1<<41)) */
-/* unused ((lib9p_getattr_t)(1<<40)) */
-/* unused ((lib9p_getattr_t)(1<<39)) */
-/* unused ((lib9p_getattr_t)(1<<38)) */
-/* unused ((lib9p_getattr_t)(1<<37)) */
-/* unused ((lib9p_getattr_t)(1<<36)) */
-/* unused ((lib9p_getattr_t)(1<<35)) */
-/* unused ((lib9p_getattr_t)(1<<34)) */
-/* unused ((lib9p_getattr_t)(1<<33)) */
-/* unused ((lib9p_getattr_t)(1<<32)) */
-/* unused ((lib9p_getattr_t)(1<<31)) */
-/* unused ((lib9p_getattr_t)(1<<30)) */
-/* unused ((lib9p_getattr_t)(1<<29)) */
-/* unused ((lib9p_getattr_t)(1<<28)) */
-/* unused ((lib9p_getattr_t)(1<<27)) */
-/* unused ((lib9p_getattr_t)(1<<26)) */
-/* unused ((lib9p_getattr_t)(1<<25)) */
-/* unused ((lib9p_getattr_t)(1<<24)) */
-/* unused ((lib9p_getattr_t)(1<<23)) */
-/* unused ((lib9p_getattr_t)(1<<22)) */
-/* unused ((lib9p_getattr_t)(1<<21)) */
-/* unused ((lib9p_getattr_t)(1<<20)) */
-/* unused ((lib9p_getattr_t)(1<<19)) */
-/* unused ((lib9p_getattr_t)(1<<18)) */
-/* unused ((lib9p_getattr_t)(1<<17)) */
-/* unused ((lib9p_getattr_t)(1<<16)) */
-/* unused ((lib9p_getattr_t)(1<<15)) */
-/* unused ((lib9p_getattr_t)(1<<14)) */
-#define LIB9P_GETATTR_DATA_VERSION ((lib9p_getattr_t)(1<<13))
-#define LIB9P_GETATTR_GEN ((lib9p_getattr_t)(1<<12))
-#define LIB9P_GETATTR_BTIME ((lib9p_getattr_t)(1<<11))
-#define LIB9P_GETATTR_BLOCKS ((lib9p_getattr_t)(1<<10))
-#define LIB9P_GETATTR_SIZE ((lib9p_getattr_t)(1<<9))
-#define LIB9P_GETATTR_INO ((lib9p_getattr_t)(1<<8))
-#define LIB9P_GETATTR_CTIME ((lib9p_getattr_t)(1<<7))
-#define LIB9P_GETATTR_MTIME ((lib9p_getattr_t)(1<<6))
-#define LIB9P_GETATTR_ATIME ((lib9p_getattr_t)(1<<5))
-#define LIB9P_GETATTR_RDEV ((lib9p_getattr_t)(1<<4))
-#define LIB9P_GETATTR_GID ((lib9p_getattr_t)(1<<3))
-#define LIB9P_GETATTR_UID ((lib9p_getattr_t)(1<<2))
-#define LIB9P_GETATTR_NLINK ((lib9p_getattr_t)(1<<1))
-#define LIB9P_GETATTR_MODE ((lib9p_getattr_t)(1<<0))
-
-#define LIB9P_GETATTR_BASIC ((lib9p_getattr_t)(0x000007ff))
-#define LIB9P_GETATTR_ALL ((lib9p_getattr_t)(0x00003fff))
+/* bits */
+#define _LIB9P_GETATTR_UNUSED_63 ((lib9p_getattr_t)(UINT64_C(1)<<63))
+#define _LIB9P_GETATTR_UNUSED_62 ((lib9p_getattr_t)(UINT64_C(1)<<62))
+#define _LIB9P_GETATTR_UNUSED_61 ((lib9p_getattr_t)(UINT64_C(1)<<61))
+#define _LIB9P_GETATTR_UNUSED_60 ((lib9p_getattr_t)(UINT64_C(1)<<60))
+#define _LIB9P_GETATTR_UNUSED_59 ((lib9p_getattr_t)(UINT64_C(1)<<59))
+#define _LIB9P_GETATTR_UNUSED_58 ((lib9p_getattr_t)(UINT64_C(1)<<58))
+#define _LIB9P_GETATTR_UNUSED_57 ((lib9p_getattr_t)(UINT64_C(1)<<57))
+#define _LIB9P_GETATTR_UNUSED_56 ((lib9p_getattr_t)(UINT64_C(1)<<56))
+#define _LIB9P_GETATTR_UNUSED_55 ((lib9p_getattr_t)(UINT64_C(1)<<55))
+#define _LIB9P_GETATTR_UNUSED_54 ((lib9p_getattr_t)(UINT64_C(1)<<54))
+#define _LIB9P_GETATTR_UNUSED_53 ((lib9p_getattr_t)(UINT64_C(1)<<53))
+#define _LIB9P_GETATTR_UNUSED_52 ((lib9p_getattr_t)(UINT64_C(1)<<52))
+#define _LIB9P_GETATTR_UNUSED_51 ((lib9p_getattr_t)(UINT64_C(1)<<51))
+#define _LIB9P_GETATTR_UNUSED_50 ((lib9p_getattr_t)(UINT64_C(1)<<50))
+#define _LIB9P_GETATTR_UNUSED_49 ((lib9p_getattr_t)(UINT64_C(1)<<49))
+#define _LIB9P_GETATTR_UNUSED_48 ((lib9p_getattr_t)(UINT64_C(1)<<48))
+#define _LIB9P_GETATTR_UNUSED_47 ((lib9p_getattr_t)(UINT64_C(1)<<47))
+#define _LIB9P_GETATTR_UNUSED_46 ((lib9p_getattr_t)(UINT64_C(1)<<46))
+#define _LIB9P_GETATTR_UNUSED_45 ((lib9p_getattr_t)(UINT64_C(1)<<45))
+#define _LIB9P_GETATTR_UNUSED_44 ((lib9p_getattr_t)(UINT64_C(1)<<44))
+#define _LIB9P_GETATTR_UNUSED_43 ((lib9p_getattr_t)(UINT64_C(1)<<43))
+#define _LIB9P_GETATTR_UNUSED_42 ((lib9p_getattr_t)(UINT64_C(1)<<42))
+#define _LIB9P_GETATTR_UNUSED_41 ((lib9p_getattr_t)(UINT64_C(1)<<41))
+#define _LIB9P_GETATTR_UNUSED_40 ((lib9p_getattr_t)(UINT64_C(1)<<40))
+#define _LIB9P_GETATTR_UNUSED_39 ((lib9p_getattr_t)(UINT64_C(1)<<39))
+#define _LIB9P_GETATTR_UNUSED_38 ((lib9p_getattr_t)(UINT64_C(1)<<38))
+#define _LIB9P_GETATTR_UNUSED_37 ((lib9p_getattr_t)(UINT64_C(1)<<37))
+#define _LIB9P_GETATTR_UNUSED_36 ((lib9p_getattr_t)(UINT64_C(1)<<36))
+#define _LIB9P_GETATTR_UNUSED_35 ((lib9p_getattr_t)(UINT64_C(1)<<35))
+#define _LIB9P_GETATTR_UNUSED_34 ((lib9p_getattr_t)(UINT64_C(1)<<34))
+#define _LIB9P_GETATTR_UNUSED_33 ((lib9p_getattr_t)(UINT64_C(1)<<33))
+#define _LIB9P_GETATTR_UNUSED_32 ((lib9p_getattr_t)(UINT64_C(1)<<32))
+#define _LIB9P_GETATTR_UNUSED_31 ((lib9p_getattr_t)(UINT64_C(1)<<31))
+#define _LIB9P_GETATTR_UNUSED_30 ((lib9p_getattr_t)(UINT64_C(1)<<30))
+#define _LIB9P_GETATTR_UNUSED_29 ((lib9p_getattr_t)(UINT64_C(1)<<29))
+#define _LIB9P_GETATTR_UNUSED_28 ((lib9p_getattr_t)(UINT64_C(1)<<28))
+#define _LIB9P_GETATTR_UNUSED_27 ((lib9p_getattr_t)(UINT64_C(1)<<27))
+#define _LIB9P_GETATTR_UNUSED_26 ((lib9p_getattr_t)(UINT64_C(1)<<26))
+#define _LIB9P_GETATTR_UNUSED_25 ((lib9p_getattr_t)(UINT64_C(1)<<25))
+#define _LIB9P_GETATTR_UNUSED_24 ((lib9p_getattr_t)(UINT64_C(1)<<24))
+#define _LIB9P_GETATTR_UNUSED_23 ((lib9p_getattr_t)(UINT64_C(1)<<23))
+#define _LIB9P_GETATTR_UNUSED_22 ((lib9p_getattr_t)(UINT64_C(1)<<22))
+#define _LIB9P_GETATTR_UNUSED_21 ((lib9p_getattr_t)(UINT64_C(1)<<21))
+#define _LIB9P_GETATTR_UNUSED_20 ((lib9p_getattr_t)(UINT64_C(1)<<20))
+#define _LIB9P_GETATTR_UNUSED_19 ((lib9p_getattr_t)(UINT64_C(1)<<19))
+#define _LIB9P_GETATTR_UNUSED_18 ((lib9p_getattr_t)(UINT64_C(1)<<18))
+#define _LIB9P_GETATTR_UNUSED_17 ((lib9p_getattr_t)(UINT64_C(1)<<17))
+#define _LIB9P_GETATTR_UNUSED_16 ((lib9p_getattr_t)(UINT64_C(1)<<16))
+#define _LIB9P_GETATTR_UNUSED_15 ((lib9p_getattr_t)(UINT64_C(1)<<15))
+#define _LIB9P_GETATTR_UNUSED_14 ((lib9p_getattr_t)(UINT64_C(1)<<14))
+#define LIB9P_GETATTR_DATA_VERSION ((lib9p_getattr_t)(UINT64_C(1)<<13))
+#define LIB9P_GETATTR_GEN ((lib9p_getattr_t)(UINT64_C(1)<<12))
+#define LIB9P_GETATTR_BTIME ((lib9p_getattr_t)(UINT64_C(1)<<11))
+#define LIB9P_GETATTR_BLOCKS ((lib9p_getattr_t)(UINT64_C(1)<<10))
+#define LIB9P_GETATTR_SIZE ((lib9p_getattr_t)(UINT64_C(1)<<9))
+#define LIB9P_GETATTR_INO ((lib9p_getattr_t)(UINT64_C(1)<<8))
+#define LIB9P_GETATTR_CTIME ((lib9p_getattr_t)(UINT64_C(1)<<7))
+#define LIB9P_GETATTR_MTIME ((lib9p_getattr_t)(UINT64_C(1)<<6))
+#define LIB9P_GETATTR_ATIME ((lib9p_getattr_t)(UINT64_C(1)<<5))
+#define LIB9P_GETATTR_RDEV ((lib9p_getattr_t)(UINT64_C(1)<<4))
+#define LIB9P_GETATTR_GID ((lib9p_getattr_t)(UINT64_C(1)<<3))
+#define LIB9P_GETATTR_UID ((lib9p_getattr_t)(UINT64_C(1)<<2))
+#define LIB9P_GETATTR_NLINK ((lib9p_getattr_t)(UINT64_C(1)<<1))
+#define LIB9P_GETATTR_MODE ((lib9p_getattr_t)(UINT64_C(1)<<0))
+/* aliases */
+#define LIB9P_GETATTR_BASIC ((lib9p_getattr_t)(2047))
+#define LIB9P_GETATTR_ALL ((lib9p_getattr_t)(16383))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_setattr_t;
-
-/* unused ((lib9p_setattr_t)(1<<31)) */
-/* unused ((lib9p_setattr_t)(1<<30)) */
-/* unused ((lib9p_setattr_t)(1<<29)) */
-/* unused ((lib9p_setattr_t)(1<<28)) */
-/* unused ((lib9p_setattr_t)(1<<27)) */
-/* unused ((lib9p_setattr_t)(1<<26)) */
-/* unused ((lib9p_setattr_t)(1<<25)) */
-/* unused ((lib9p_setattr_t)(1<<24)) */
-/* unused ((lib9p_setattr_t)(1<<23)) */
-/* unused ((lib9p_setattr_t)(1<<22)) */
-/* unused ((lib9p_setattr_t)(1<<21)) */
-/* unused ((lib9p_setattr_t)(1<<20)) */
-/* unused ((lib9p_setattr_t)(1<<19)) */
-/* unused ((lib9p_setattr_t)(1<<18)) */
-/* unused ((lib9p_setattr_t)(1<<17)) */
-/* unused ((lib9p_setattr_t)(1<<16)) */
-/* unused ((lib9p_setattr_t)(1<<15)) */
-/* unused ((lib9p_setattr_t)(1<<14)) */
-/* unused ((lib9p_setattr_t)(1<<13)) */
-/* unused ((lib9p_setattr_t)(1<<12)) */
-/* unused ((lib9p_setattr_t)(1<<11)) */
-/* unused ((lib9p_setattr_t)(1<<10)) */
-/* unused ((lib9p_setattr_t)(1<<9)) */
-#define LIB9P_SETATTR_MTIME_SET ((lib9p_setattr_t)(1<<8))
-#define LIB9P_SETATTR_ATIME_SET ((lib9p_setattr_t)(1<<7))
-#define LIB9P_SETATTR_CTIME ((lib9p_setattr_t)(1<<6))
-#define LIB9P_SETATTR_MTIME ((lib9p_setattr_t)(1<<5))
-#define LIB9P_SETATTR_ATIME ((lib9p_setattr_t)(1<<4))
-#define LIB9P_SETATTR_SIZE ((lib9p_setattr_t)(1<<3))
-#define LIB9P_SETATTR_GID ((lib9p_setattr_t)(1<<2))
-#define LIB9P_SETATTR_UID ((lib9p_setattr_t)(1<<1))
-#define LIB9P_SETATTR_MODE ((lib9p_setattr_t)(1<<0))
+/* bits */
+#define _LIB9P_SETATTR_UNUSED_31 ((lib9p_setattr_t)(UINT32_C(1)<<31))
+#define _LIB9P_SETATTR_UNUSED_30 ((lib9p_setattr_t)(UINT32_C(1)<<30))
+#define _LIB9P_SETATTR_UNUSED_29 ((lib9p_setattr_t)(UINT32_C(1)<<29))
+#define _LIB9P_SETATTR_UNUSED_28 ((lib9p_setattr_t)(UINT32_C(1)<<28))
+#define _LIB9P_SETATTR_UNUSED_27 ((lib9p_setattr_t)(UINT32_C(1)<<27))
+#define _LIB9P_SETATTR_UNUSED_26 ((lib9p_setattr_t)(UINT32_C(1)<<26))
+#define _LIB9P_SETATTR_UNUSED_25 ((lib9p_setattr_t)(UINT32_C(1)<<25))
+#define _LIB9P_SETATTR_UNUSED_24 ((lib9p_setattr_t)(UINT32_C(1)<<24))
+#define _LIB9P_SETATTR_UNUSED_23 ((lib9p_setattr_t)(UINT32_C(1)<<23))
+#define _LIB9P_SETATTR_UNUSED_22 ((lib9p_setattr_t)(UINT32_C(1)<<22))
+#define _LIB9P_SETATTR_UNUSED_21 ((lib9p_setattr_t)(UINT32_C(1)<<21))
+#define _LIB9P_SETATTR_UNUSED_20 ((lib9p_setattr_t)(UINT32_C(1)<<20))
+#define _LIB9P_SETATTR_UNUSED_19 ((lib9p_setattr_t)(UINT32_C(1)<<19))
+#define _LIB9P_SETATTR_UNUSED_18 ((lib9p_setattr_t)(UINT32_C(1)<<18))
+#define _LIB9P_SETATTR_UNUSED_17 ((lib9p_setattr_t)(UINT32_C(1)<<17))
+#define _LIB9P_SETATTR_UNUSED_16 ((lib9p_setattr_t)(UINT32_C(1)<<16))
+#define _LIB9P_SETATTR_UNUSED_15 ((lib9p_setattr_t)(UINT32_C(1)<<15))
+#define _LIB9P_SETATTR_UNUSED_14 ((lib9p_setattr_t)(UINT32_C(1)<<14))
+#define _LIB9P_SETATTR_UNUSED_13 ((lib9p_setattr_t)(UINT32_C(1)<<13))
+#define _LIB9P_SETATTR_UNUSED_12 ((lib9p_setattr_t)(UINT32_C(1)<<12))
+#define _LIB9P_SETATTR_UNUSED_11 ((lib9p_setattr_t)(UINT32_C(1)<<11))
+#define _LIB9P_SETATTR_UNUSED_10 ((lib9p_setattr_t)(UINT32_C(1)<<10))
+#define _LIB9P_SETATTR_UNUSED_9 ((lib9p_setattr_t)(UINT32_C(1)<<9))
+#define LIB9P_SETATTR_MTIME_SET ((lib9p_setattr_t)(UINT32_C(1)<<8))
+#define LIB9P_SETATTR_ATIME_SET ((lib9p_setattr_t)(UINT32_C(1)<<7))
+#define LIB9P_SETATTR_CTIME ((lib9p_setattr_t)(UINT32_C(1)<<6))
+#define LIB9P_SETATTR_MTIME ((lib9p_setattr_t)(UINT32_C(1)<<5))
+#define LIB9P_SETATTR_ATIME ((lib9p_setattr_t)(UINT32_C(1)<<4))
+#define LIB9P_SETATTR_SIZE ((lib9p_setattr_t)(UINT32_C(1)<<3))
+#define LIB9P_SETATTR_GID ((lib9p_setattr_t)(UINT32_C(1)<<2))
+#define LIB9P_SETATTR_UID ((lib9p_setattr_t)(UINT32_C(1)<<1))
+#define LIB9P_SETATTR_MODE ((lib9p_setattr_t)(UINT32_C(1)<<0))
/* size = 1 ; max_iov = 1 ; max_copy = 1 */
typedef uint8_t lib9p_lock_type_t;
-#define LIB9P_LOCK_TYPE_RDLCK ((lib9p_lock_type_t)UINT8_C(0))
-#define LIB9P_LOCK_TYPE_WRLCK ((lib9p_lock_type_t)UINT8_C(1))
-#define LIB9P_LOCK_TYPE_UNLCK ((lib9p_lock_type_t)UINT8_C(2))
+#define LIB9P_LOCK_TYPE_RDLCK ((lib9p_lock_type_t)(0))
+#define LIB9P_LOCK_TYPE_WRLCK ((lib9p_lock_type_t)(1))
+#define LIB9P_LOCK_TYPE_UNLCK ((lib9p_lock_type_t)(2))
/* size = 4 ; max_iov = 1 ; max_copy = 4 */
typedef uint32_t lib9p_lock_flags_t;
-
-/* unused ((lib9p_lock_flags_t)(1<<31)) */
-/* unused ((lib9p_lock_flags_t)(1<<30)) */
-/* unused ((lib9p_lock_flags_t)(1<<29)) */
-/* unused ((lib9p_lock_flags_t)(1<<28)) */
-/* unused ((lib9p_lock_flags_t)(1<<27)) */
-/* unused ((lib9p_lock_flags_t)(1<<26)) */
-/* unused ((lib9p_lock_flags_t)(1<<25)) */
-/* unused ((lib9p_lock_flags_t)(1<<24)) */
-/* unused ((lib9p_lock_flags_t)(1<<23)) */
-/* unused ((lib9p_lock_flags_t)(1<<22)) */
-/* unused ((lib9p_lock_flags_t)(1<<21)) */
-/* unused ((lib9p_lock_flags_t)(1<<20)) */
-/* unused ((lib9p_lock_flags_t)(1<<19)) */
-/* unused ((lib9p_lock_flags_t)(1<<18)) */
-/* unused ((lib9p_lock_flags_t)(1<<17)) */
-/* unused ((lib9p_lock_flags_t)(1<<16)) */
-/* unused ((lib9p_lock_flags_t)(1<<15)) */
-/* unused ((lib9p_lock_flags_t)(1<<14)) */
-/* unused ((lib9p_lock_flags_t)(1<<13)) */
-/* unused ((lib9p_lock_flags_t)(1<<12)) */
-/* unused ((lib9p_lock_flags_t)(1<<11)) */
-/* unused ((lib9p_lock_flags_t)(1<<10)) */
-/* unused ((lib9p_lock_flags_t)(1<<9)) */
-/* unused ((lib9p_lock_flags_t)(1<<8)) */
-/* unused ((lib9p_lock_flags_t)(1<<7)) */
-/* unused ((lib9p_lock_flags_t)(1<<6)) */
-/* unused ((lib9p_lock_flags_t)(1<<5)) */
-/* unused ((lib9p_lock_flags_t)(1<<4)) */
-/* unused ((lib9p_lock_flags_t)(1<<3)) */
-/* unused ((lib9p_lock_flags_t)(1<<2)) */
-#define LIB9P_LOCK_FLAGS_RECLAIM ((lib9p_lock_flags_t)(1<<1))
-#define LIB9P_LOCK_FLAGS_BLOCK ((lib9p_lock_flags_t)(1<<0))
+/* bits */
+#define _LIB9P_LOCK_FLAGS_UNUSED_31 ((lib9p_lock_flags_t)(UINT32_C(1)<<31))
+#define _LIB9P_LOCK_FLAGS_UNUSED_30 ((lib9p_lock_flags_t)(UINT32_C(1)<<30))
+#define _LIB9P_LOCK_FLAGS_UNUSED_29 ((lib9p_lock_flags_t)(UINT32_C(1)<<29))
+#define _LIB9P_LOCK_FLAGS_UNUSED_28 ((lib9p_lock_flags_t)(UINT32_C(1)<<28))
+#define _LIB9P_LOCK_FLAGS_UNUSED_27 ((lib9p_lock_flags_t)(UINT32_C(1)<<27))
+#define _LIB9P_LOCK_FLAGS_UNUSED_26 ((lib9p_lock_flags_t)(UINT32_C(1)<<26))
+#define _LIB9P_LOCK_FLAGS_UNUSED_25 ((lib9p_lock_flags_t)(UINT32_C(1)<<25))
+#define _LIB9P_LOCK_FLAGS_UNUSED_24 ((lib9p_lock_flags_t)(UINT32_C(1)<<24))
+#define _LIB9P_LOCK_FLAGS_UNUSED_23 ((lib9p_lock_flags_t)(UINT32_C(1)<<23))
+#define _LIB9P_LOCK_FLAGS_UNUSED_22 ((lib9p_lock_flags_t)(UINT32_C(1)<<22))
+#define _LIB9P_LOCK_FLAGS_UNUSED_21 ((lib9p_lock_flags_t)(UINT32_C(1)<<21))
+#define _LIB9P_LOCK_FLAGS_UNUSED_20 ((lib9p_lock_flags_t)(UINT32_C(1)<<20))
+#define _LIB9P_LOCK_FLAGS_UNUSED_19 ((lib9p_lock_flags_t)(UINT32_C(1)<<19))
+#define _LIB9P_LOCK_FLAGS_UNUSED_18 ((lib9p_lock_flags_t)(UINT32_C(1)<<18))
+#define _LIB9P_LOCK_FLAGS_UNUSED_17 ((lib9p_lock_flags_t)(UINT32_C(1)<<17))
+#define _LIB9P_LOCK_FLAGS_UNUSED_16 ((lib9p_lock_flags_t)(UINT32_C(1)<<16))
+#define _LIB9P_LOCK_FLAGS_UNUSED_15 ((lib9p_lock_flags_t)(UINT32_C(1)<<15))
+#define _LIB9P_LOCK_FLAGS_UNUSED_14 ((lib9p_lock_flags_t)(UINT32_C(1)<<14))
+#define _LIB9P_LOCK_FLAGS_UNUSED_13 ((lib9p_lock_flags_t)(UINT32_C(1)<<13))
+#define _LIB9P_LOCK_FLAGS_UNUSED_12 ((lib9p_lock_flags_t)(UINT32_C(1)<<12))
+#define _LIB9P_LOCK_FLAGS_UNUSED_11 ((lib9p_lock_flags_t)(UINT32_C(1)<<11))
+#define _LIB9P_LOCK_FLAGS_UNUSED_10 ((lib9p_lock_flags_t)(UINT32_C(1)<<10))
+#define _LIB9P_LOCK_FLAGS_UNUSED_9 ((lib9p_lock_flags_t)(UINT32_C(1)<<9))
+#define _LIB9P_LOCK_FLAGS_UNUSED_8 ((lib9p_lock_flags_t)(UINT32_C(1)<<8))
+#define _LIB9P_LOCK_FLAGS_UNUSED_7 ((lib9p_lock_flags_t)(UINT32_C(1)<<7))
+#define _LIB9P_LOCK_FLAGS_UNUSED_6 ((lib9p_lock_flags_t)(UINT32_C(1)<<6))
+#define _LIB9P_LOCK_FLAGS_UNUSED_5 ((lib9p_lock_flags_t)(UINT32_C(1)<<5))
+#define _LIB9P_LOCK_FLAGS_UNUSED_4 ((lib9p_lock_flags_t)(UINT32_C(1)<<4))
+#define _LIB9P_LOCK_FLAGS_UNUSED_3 ((lib9p_lock_flags_t)(UINT32_C(1)<<3))
+#define _LIB9P_LOCK_FLAGS_UNUSED_2 ((lib9p_lock_flags_t)(UINT32_C(1)<<2))
+#define LIB9P_LOCK_FLAGS_RECLAIM ((lib9p_lock_flags_t)(UINT32_C(1)<<1))
+#define LIB9P_LOCK_FLAGS_BLOCK ((lib9p_lock_flags_t)(UINT32_C(1)<<0))
/* size = 1 ; max_iov = 1 ; max_copy = 1 */
typedef uint8_t lib9p_lock_status_t;
-#define LIB9P_LOCK_STATUS_SUCCESS ((lib9p_lock_status_t)UINT8_C(0))
-#define LIB9P_LOCK_STATUS_BLOCKED ((lib9p_lock_status_t)UINT8_C(1))
-#define LIB9P_LOCK_STATUS_ERROR ((lib9p_lock_status_t)UINT8_C(2))
-#define LIB9P_LOCK_STATUS_GRACE ((lib9p_lock_status_t)UINT8_C(3))
+#define LIB9P_LOCK_STATUS_SUCCESS ((lib9p_lock_status_t)(0))
+#define LIB9P_LOCK_STATUS_BLOCKED ((lib9p_lock_status_t)(1))
+#define LIB9P_LOCK_STATUS_ERROR ((lib9p_lock_status_t)(2))
+#define LIB9P_LOCK_STATUS_GRACE ((lib9p_lock_status_t)(3))
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
diff --git a/lib9p/protogen/c.py b/lib9p/protogen/c.py
index 5e67939..cc1daea 100644
--- a/lib9p/protogen/c.py
+++ b/lib9p/protogen/c.py
@@ -118,7 +118,7 @@ const char *const {c9util.ident('_table_ver_name')}[{c9util.ver_enum('NUM')}] =
+ "".join(
(
"1"
- if bit.cat in (idl.BitCat.USED, idl.BitCat.SUBFIELD)
+ if (bit.cat == "USED" or isinstance(bit.cat, idl.BitNum))
and ver in bit.in_versions
else "0"
)
diff --git a/lib9p/protogen/c9util.py b/lib9p/protogen/c9util.py
index e7ad999..85fd47b 100644
--- a/lib9p/protogen/c9util.py
+++ b/lib9p/protogen/c9util.py
@@ -3,6 +3,7 @@
# Copyright (C) 2024-2025 Luke T. Shumaker <lukeshu@lukeshu.com>
# SPDX-License-Identifier: AGPL-3.0-or-later
+import re
import typing
import idl
@@ -90,20 +91,30 @@ def typename(typ: idl.Type, parent: idl.StructMember | None = None) -> str:
raise ValueError(f"not a type: {typ.__class__.__name__}")
-def idl_expr(expr: idl.Expr, lookup_sym: typing.Callable[[str], str]) -> str:
+def idl_expr(
+ expr: idl.Expr, lookup_sym: typing.Callable[[str], str], bitwidth: int = 0
+) -> str:
ret: list[str] = []
for tok in expr.tokens:
match tok:
case idl.ExprOp():
ret.append(tok.op)
case idl.ExprLit():
- ret.append(str(tok.val))
- case idl.ExprSym(symname="s32_max"):
- ret.append("INT32_MAX")
- case idl.ExprSym(symname="s64_max"):
- ret.append("INT64_MAX")
+ if bitwidth:
+ ret.append(f"{tok.val:#0{bitwidth}b}")
+ else:
+ ret.append(str(tok.val))
case idl.ExprSym():
- ret.append(lookup_sym(tok.symname))
+ if m := re.fullmatch(r"^u(8|16|32|64)_max$", tok.symname):
+ ret.append(f"UINT{m.group(1)}_MAX")
+ elif m := re.fullmatch(r"^s(8|16|32|64)_max$", tok.symname):
+ ret.append(f"INT{m.group(1)}_MAX")
+ else:
+ ret.append(lookup_sym(tok.symname))
+ case idl.ExprOff():
+ ret.append(lookup_sym("&" + tok.membname))
+ case idl.ExprNum():
+ ret.append(Ident(add_prefix(f"{tok.numname}_".upper(), tok.valname)))
case _:
assert False
return " ".join(ret)
diff --git a/lib9p/protogen/c_marshal.py b/lib9p/protogen/c_marshal.py
index 74b64f5..4dab864 100644
--- a/lib9p/protogen/c_marshal.py
+++ b/lib9p/protogen/c_marshal.py
@@ -23,7 +23,7 @@ __all__ = ["gen_c_marshal"]
class OffsetExpr:
static: int
cond: dict[frozenset[str], "OffsetExpr"]
- rep: list[tuple[idlutil.Path, "OffsetExpr"]]
+ rep: list[tuple[idlutil.Path | int, "OffsetExpr"]]
def __init__(self) -> None:
self.static = 0
@@ -52,14 +52,20 @@ class OffsetExpr:
if self.static:
oneline.append(str(self.static))
for cnt, sub in self.rep:
+ if isinstance(cnt, int):
+ cnt_str = str(cnt)
+ cnt_typ = "size_t"
+ else:
+ cnt_str = cnt.c_str(root)
+ cnt_typ = c9util.typename(cnt.elems[-1].typ)
if not sub.cond and not sub.rep:
if sub.static == 1:
- oneline.append(cnt.c_str(root))
+ oneline.append(cnt_str)
else:
- oneline.append(f"({cnt.c_str(root)})*{sub.static}")
+ oneline.append(f"({cnt_str})*{sub.static}")
continue
loopvar = chr(ord("i") + loop_depth)
- multiline += f"{'\t'*indent_depth}for ({c9util.typename(cnt.elems[-1].typ)} {loopvar} = 0; {loopvar} < {cnt.c_str(root)}; {loopvar}++) {{\n"
+ multiline += f"{'\t'*indent_depth}for ({cnt_typ} {loopvar} = 0; {loopvar} < {cnt_str}; {loopvar}++) {{\n"
multiline += sub.gen_c("", dstvar, root, indent_depth + 1, loop_depth + 1)
multiline += f"{'\t'*indent_depth}}}\n"
for vers, sub in self.cond.items():
@@ -113,8 +119,12 @@ def get_offset_expr(typ: idl.UserType, recurse: OffsetExprRecursion) -> OffsetEx
member_path = expr_stack[-1].path
member = member_path.elems[-1]
assert member.cnt
- cnt_path = member_path.parent().add(member.cnt)
- expr_stack[-2].expr.rep.append((cnt_path, expr_stack[-1].expr))
+ cnt: idlutil.Path | int
+ if isinstance(member.cnt, int):
+ cnt = member.cnt
+ else:
+ cnt = member_path.parent().add(member.cnt)
+ expr_stack[-2].expr.rep.append((cnt, expr_stack[-1].expr))
expr_stack = expr_stack[:-1]
def handle(
@@ -268,11 +278,13 @@ def gen_c_marshal(versions: set[str], typs: list[idl.UserType]) -> str:
if not member.val:
continue
for tok in member.val.tokens:
- if not isinstance(tok, idl.ExprSym):
- continue
- if tok.symname == "end" or tok.symname.startswith("&"):
- if tok.symname not in offsets:
- offsets.append(tok.symname)
+ match tok:
+ case idl.ExprSym(symname="end"):
+ if tok.symname not in offsets:
+ offsets.append(tok.symname)
+ case idl.ExprOff():
+ if f"&{tok.membname}" not in offsets:
+ offsets.append(f"&{tok.membname}")
for name in offsets:
name_prefix = f"offsetof{''.join('_'+m.membname for m in path.elems)}_"
if name == "end":
@@ -313,15 +325,20 @@ def gen_c_marshal(versions: set[str], typs: list[idl.UserType]) -> str:
)
indent_stack.append(IndentLevel(ifdef=True))
if child.cnt:
- cnt_path = path.parent().add(child.cnt)
+ if isinstance(child.cnt, int):
+ cnt_str = str(child.cnt)
+ cnt_typ = "size_t"
+ else:
+ cnt_str = path.parent().add(child.cnt).c_str("val->")
+ cnt_typ = c9util.typename(child.cnt.typ)
if child.typ.static_size == 1: # SPECIAL (zerocopy)
if path.root.typname == "stat": # SPECIAL (stat)
- ret += f"{'\t'*indent_lvl()}MARSHAL_BYTES(ctx, {path.c_str('val->')[:-3]}, {cnt_path.c_str('val->')});\n"
+ ret += f"{'\t'*indent_lvl()}MARSHAL_BYTES(ctx, {path.c_str('val->')[:-3]}, {cnt_str});\n"
else:
- ret += f"{'\t'*indent_lvl()}MARSHAL_BYTES_ZEROCOPY(ctx, {path.c_str('val->')[:-3]}, {cnt_path.c_str('val->')});\n"
+ ret += f"{'\t'*indent_lvl()}MARSHAL_BYTES_ZEROCOPY(ctx, {path.c_str('val->')[:-3]}, {cnt_str});\n"
return idlutil.WalkCmd.KEEP_GOING, pop
loopvar = chr(ord("i") + loopdepth - 1)
- ret += f"{'\t'*indent_lvl()}for ({c9util.typename(child.cnt.typ)} {loopvar} = 0; {loopvar} < {cnt_path.c_str('val->')}; {loopvar}++) {{\n"
+ ret += f"{'\t'*indent_lvl()}for ({cnt_typ} {loopvar} = 0; {loopvar} < {cnt_str}; {loopvar}++) {{\n"
indent_stack.append(IndentLevel(ifdef=False))
if not isinstance(child.typ, idl.Struct):
if child.val:
diff --git a/lib9p/protogen/c_unmarshal.py b/lib9p/protogen/c_unmarshal.py
index 018d750..34635f9 100644
--- a/lib9p/protogen/c_unmarshal.py
+++ b/lib9p/protogen/c_unmarshal.py
@@ -93,15 +93,20 @@ def gen_c_unmarshal(versions: set[str], typs: list[idl.UserType]) -> str:
)
indent_stack.append(IndentLevel(ifdef=True))
if child.cnt:
- cnt_path = path.parent().add(child.cnt)
+ if isinstance(child.cnt, int):
+ cnt_str = str(child.cnt)
+ cnt_typ = "size_t"
+ else:
+ cnt_str = path.parent().add(child.cnt).c_str("out->")
+ cnt_typ = c9util.typename(child.cnt.typ)
if child.typ.static_size == 1: # SPECIAL (zerocopy)
- ret += f"{'\t'*indent_lvl()}UNMARSHAL_BYTES(ctx, {path.c_str('out->')[:-3]}, {cnt_path.c_str('out->')});\n"
+ ret += f"{'\t'*indent_lvl()}UNMARSHAL_BYTES(ctx, {path.c_str('out->')[:-3]}, {cnt_str});\n"
return idlutil.WalkCmd.KEEP_GOING, pop
ret += f"{'\t'*indent_lvl()}{path.c_str('out->')[:-3]} = extra;\n"
- ret += f"{'\t'*indent_lvl()}extra += sizeof({path.c_str('out->')[:-3]}[0]) * {cnt_path.c_str('out->')};\n"
+ ret += f"{'\t'*indent_lvl()}extra += sizeof({path.c_str('out->')[:-3]}[0]) * {cnt_str};\n"
loopdepth = sum(1 for elem in path.elems if elem.cnt)
loopvar = chr(ord("i") + loopdepth - 1)
- ret += f"{'\t'*indent_lvl()}for ({c9util.typename(child.cnt.typ)} {loopvar} = 0; {loopvar} < {cnt_path.c_str('out->')}; {loopvar}++) {{\n"
+ ret += f"{'\t'*indent_lvl()}for ({cnt_typ} {loopvar} = 0; {loopvar} < {cnt_str}; {loopvar}++) {{\n"
indent_stack.append(IndentLevel(ifdef=False))
if not isinstance(child.typ, idl.Struct):
if child.val:
diff --git a/lib9p/protogen/c_validate.py b/lib9p/protogen/c_validate.py
index e315b60..535a750 100644
--- a/lib9p/protogen/c_validate.py
+++ b/lib9p/protogen/c_validate.py
@@ -24,11 +24,11 @@ def should_save_offset(parent: idl.Struct, child: idl.StructMember) -> bool:
for sibling in parent.members:
if sibling.val:
for tok in sibling.val.tokens:
- if isinstance(tok, idl.ExprSym) and tok.symname == f"&{child.membname}":
+ if isinstance(tok, idl.ExprOff) and tok.membname == child.membname:
return True
if sibling.max:
for tok in sibling.max.tokens:
- if isinstance(tok, idl.ExprSym) and tok.symname == f"&{child.membname}":
+ if isinstance(tok, idl.ExprOff) and tok.membname == child.membname:
return True
return False
@@ -132,21 +132,33 @@ def gen_c_validate(versions: set[str], typs: list[idl.UserType]) -> str:
if should_save_offset(parent, child):
ret += f"{'\t'*indent_lvl()}uint32_t offsetof{''.join('_'+m.membname for m in path.elems)} = net_offset + {incr_buf};\n"
if child.cnt:
- assert child.cnt.typ.static_size
- cnt_path = path.parent().add(child.cnt)
- incr_flush()
+ if isinstance(child.cnt, int):
+ cnt_str = str(child.cnt)
+ cnt_typ = "size_t"
+ else:
+ assert child.cnt.typ.static_size
+ incr_flush()
+ cnt_str = f"LAST_U{child.cnt.typ.static_size*8}LE()"
+ cnt_typ = c9util.typename(child.cnt.typ)
if child.membname == "utf8": # SPECIAL (string)
+ assert child.typ.static_size == 1
# Yes, this is content-validation and "belongs" in
# gen_validate_content(), not here. But it's just
# easier this way.
- ret += f"{'\t'*indent_lvl()}VALIDATE_NET_UTF8(LAST_U{child.cnt.typ.static_size*8}LE());\n"
+ incr_flush()
+ ret += f"{'\t'*indent_lvl()}VALIDATE_NET_UTF8({cnt_str});\n"
return
if child.typ.static_size == 1: # SPECIAL (zerocopy)
- ret += f"{'\t'*indent_lvl()}VALIDATE_NET_BYTES(LAST_U{child.cnt.typ.static_size*8}LE());\n"
+ if isinstance(child.cnt, int):
+ incr_buf += child.cnt
+ return
+ incr_flush()
+ ret += f"{'\t'*indent_lvl()}VALIDATE_NET_BYTES({cnt_str});\n"
return
loopdepth = sum(1 for elem in path.elems if elem.cnt)
loopvar = chr(ord("i") + loopdepth - 1)
- ret += f"{'\t'*indent_lvl()}for ({c9util.typename(child.cnt.typ)} {loopvar} = 0, cnt = LAST_U{child.cnt.typ.static_size*8}LE(); {loopvar} < cnt; {loopvar}++) {{\n"
+ incr_flush()
+ ret += f"{'\t'*indent_lvl()}for ({cnt_typ} {loopvar} = 0, cnt = {cnt_str}; {loopvar} < cnt; {loopvar}++) {{\n"
indent_stack.append(IndentLevel(ifdef=False))
ret += f"{'\t'*indent_lvl()}RESERVE_HOST_BYTES(sizeof({c9util.typename(child.typ)}));\n"
if not isinstance(child.typ, idl.Struct):
diff --git a/lib9p/protogen/h.py b/lib9p/protogen/h.py
index 7785ca1..13c3f89 100644
--- a/lib9p/protogen/h.py
+++ b/lib9p/protogen/h.py
@@ -268,99 +268,11 @@ enum {c9util.ident('version')} {{
match typ:
case idl.Number():
- ret += f"typedef {c9util.typename(typ.prim)} {c9util.typename(typ)};\n"
- prefix = f"{c9util.IDENT(typ.typname)}_"
- namewidth = max(len(name) for name in typ.vals)
- for name, val in typ.vals.items():
- ret += f"#define {prefix}{name:<{namewidth}} (({c9util.typename(typ)})UINT{typ.static_size*8}_C({val}))\n"
+ ret += gen_number(typ)
case idl.Bitfield():
- ret += f"typedef {c9util.typename(typ.prim)} {c9util.typename(typ)};\n"
-
- def bitname(val: idl.Bit | idl.BitAlias) -> str:
- s = val.bitname
- match val:
- case idl.Bit(cat=idl.BitCat.RESERVED):
- s = "_RESERVED_" + s
- case idl.Bit(cat=idl.BitCat.SUBFIELD):
- assert isinstance(typ, idl.Bitfield)
- n = sum(
- 1
- for b in typ.bits[: val.num]
- if b.cat == idl.BitCat.SUBFIELD
- and b.bitname == val.bitname
- )
- s = f"_{s}_{n}"
- case idl.Bit(cat=idl.BitCat.UNUSED):
- return ""
- return c9util.Ident(c9util.add_prefix(typ.typname.upper() + "_", s))
-
- namewidth = max(
- len(bitname(val)) for val in [*typ.bits, *typ.names.values()]
- )
-
- ret += "\n"
- for bit in reversed(typ.bits):
- vers = bit.in_versions
- if bit.cat == idl.BitCat.UNUSED:
- vers = typ.in_versions
- ret += cutil.ifdef_push(2, c9util.ver_ifdef(vers))
-
- # It is important all of the `beg` strings have
- # the same length.
- end = ""
- match bit.cat:
- case (
- idl.BitCat.USED | idl.BitCat.RESERVED | idl.BitCat.SUBFIELD
- ):
- if cutil.ifdef_leaf_is_noop():
- beg = "#define "
- else:
- beg = "# define"
- case idl.BitCat.UNUSED:
- beg = "/* unused"
- end = " */"
-
- c_name = bitname(bit)
- c_val = f"1<<{bit.num}"
- ret += f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
- if aliases := [
- alias
- for alias in typ.names.values()
- if isinstance(alias, idl.BitAlias)
- ]:
- ret += "\n"
-
- for alias in aliases:
- ret += cutil.ifdef_push(2, c9util.ver_ifdef(alias.in_versions))
-
- end = ""
- if cutil.ifdef_leaf_is_noop():
- beg = "#define "
- else:
- beg = "# define"
-
- c_name = bitname(alias)
- c_val = alias.val
- ret += f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
- ret += cutil.ifdef_pop(1)
- del bitname
+ ret += gen_bitfield(typ)
case idl.Struct(): # and idl.Message():
- ret += c9util.typename(typ) + " {"
- if not typ.members:
- ret += "};\n"
- continue
- ret += "\n"
-
- typewidth = max(len(c9util.typename(m.typ, m)) for m in typ.members)
-
- for member in typ.members:
- if member.val:
- continue
- ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
- ret += f"\t{c9util.typename(member.typ, member):<{typewidth}} {'*' if member.cnt else ' '}{member.membname};\n"
- ret += cutil.ifdef_pop(1)
- ret += "};\n"
- del typ
+ ret += gen_struct(typ)
ret += cutil.ifdef_pop(0)
ret += """
@@ -445,3 +357,173 @@ enum {c9util.ident('version')} {{
ret += "};\n"
return ret
+
+
+def gen_number(typ: idl.Number) -> str:
+ ret = f"typedef {c9util.typename(typ.prim)} {c9util.typename(typ)};\n"
+
+ def lookup_sym(sym: str) -> str:
+ assert False
+
+ def cname(base: str) -> str:
+ prefix = f"{typ.typname}_".upper()
+ return c9util.Ident(c9util.add_prefix(prefix, base))
+
+ namewidth = max(len(cname(name)) for name in typ.vals)
+ for name, val in typ.vals.items():
+ c_name = cname(name)
+ c_val = c9util.idl_expr(val, lookup_sym)
+ ret += f"#define {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val}))\n"
+ return ret
+
+
+def gen_bitfield(typ: idl.Bitfield) -> str:
+ ret = f"typedef {c9util.typename(typ.prim)} {c9util.typename(typ)};\n"
+
+ def lookup_sym(sym: str) -> str:
+ assert False
+
+ # There are 4 parts here: bits, aliases, masks, and numbers.
+
+ # 1. bits
+
+ def bitname(bit: idl.Bit) -> str:
+ prefix = f"{typ.typname}_".upper()
+ base = bit.bitname
+ match bit:
+ case idl.Bit(cat="RESERVED"):
+ base = "_RESERVED_" + base
+ case idl.Bit(cat=idl.BitNum()):
+ base += "_*"
+ case idl.Bit(cat="UNUSED"):
+ base = f"_UNUSED_{bit.num}"
+ return c9util.Ident(c9util.add_prefix(prefix, base))
+
+ namewidth = max(len(bitname(bit)) for bit in typ.bits)
+
+ ret += "/* bits */\n"
+ for bit in reversed(typ.bits):
+ vers = bit.in_versions
+ if bit.cat == "UNUSED":
+ vers = typ.in_versions
+ ret += cutil.ifdef_push(2, c9util.ver_ifdef(vers))
+
+ # It is important all of the `beg` strings have
+ # the same length.
+ end = ""
+ match bit.cat:
+ case "USED" | "RESERVED" | "UNUSED":
+ if cutil.ifdef_leaf_is_noop():
+ beg = "#define "
+ else:
+ beg = "# define"
+ case idl.BitNum():
+ beg = "/* number"
+ end = " */"
+
+ c_name = bitname(bit)
+ c_val = f"UINT{typ.static_size*8}_C(1)<<{bit.num}"
+ ret += (
+ f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
+ )
+ ret += cutil.ifdef_pop(1)
+
+ # 2. aliases
+ if typ.aliases:
+
+ def aliasname(alias: idl.BitAlias) -> str:
+ prefix = f"{typ.typname}_".upper()
+ base = alias.bitname
+ return c9util.Ident(c9util.add_prefix(prefix, base))
+
+ ret += "/* aliases */\n"
+ for alias in typ.aliases.values():
+ ret += cutil.ifdef_push(2, c9util.ver_ifdef(alias.in_versions))
+
+ end = ""
+ if cutil.ifdef_leaf_is_noop():
+ beg = "#define "
+ else:
+ beg = "# define"
+
+ c_name = aliasname(alias)
+ c_val = c9util.idl_expr(alias.val, lookup_sym)
+ ret += f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
+
+ ret += cutil.ifdef_pop(1)
+
+ # 3. masks
+ if typ.masks:
+
+ def maskname(mask: idl.BitAlias) -> str:
+ prefix = f"{typ.typname}_".upper()
+ base = mask.bitname
+ return c9util.Ident(c9util.add_prefix(prefix, base) + "_MASK")
+
+ ret += "/* masks */\n"
+ for mask in typ.masks.values():
+ ret += cutil.ifdef_push(2, c9util.ver_ifdef(mask.in_versions))
+
+ end = ""
+ if cutil.ifdef_leaf_is_noop():
+ beg = "#define "
+ else:
+ beg = "# define"
+
+ c_name = maskname(mask)
+ c_val = c9util.idl_expr(mask.val, lookup_sym, bitwidth=typ.static_size * 8)
+ ret += f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
+
+ ret += cutil.ifdef_pop(1)
+
+ # 4. numbers
+ def numname(num: idl.BitNum, base: str) -> str:
+ prefix = f"{typ.typname}_{num.numname}_".upper()
+ return c9util.Ident(c9util.add_prefix(prefix, base))
+
+ for num in typ.nums.values():
+ namewidth = max(
+ len(numname(num, base))
+ for base in [
+ *[alias.bitname for alias in num.vals.values()],
+ "MASK",
+ ]
+ )
+ ret += f"/* number: {num.numname} */\n"
+ for alias in num.vals.values():
+ ret += cutil.ifdef_push(2, c9util.ver_ifdef(alias.in_versions))
+
+ end = ""
+ if cutil.ifdef_leaf_is_noop():
+ beg = "#define "
+ else:
+ beg = "# define"
+
+ c_name = numname(num, alias.bitname)
+ c_val = c9util.idl_expr(alias.val, lookup_sym)
+ ret += f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
+ ret += cutil.ifdef_pop(1)
+ c_name = numname(num, "MASK")
+ c_val = f"{num.mask:#0{typ.static_size*8}b}"
+ ret += (
+ f"{beg} {c_name:<{namewidth}} (({c9util.typename(typ)})({c_val})){end}\n"
+ )
+
+ return ret
+
+
+def gen_struct(typ: idl.Struct) -> str: # and idl.Message
+ ret = c9util.typename(typ) + " {"
+ if typ.members:
+ ret += "\n"
+
+ typewidth = max(len(c9util.typename(m.typ, m)) for m in typ.members)
+
+ for member in typ.members:
+ if member.val:
+ continue
+ ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
+ ret += f"\t{c9util.typename(member.typ, member):<{typewidth}} {'*' if member.cnt else ' '}{member.membname};\n"
+ ret += cutil.ifdef_pop(1)
+ ret += "};\n"
+ return ret
diff --git a/lib9p/srv.c b/lib9p/srv.c
index 50d0b78..a29a4cb 100644
--- a/lib9p/srv.c
+++ b/lib9p/srv.c
@@ -822,7 +822,7 @@ static void handle_Topen(struct _lib9p_srv_req *ctx,
struct srv_pathinfo *pathinfo = pathmap_load(&ctx->parent_sess->paths, fidinfo->path);
assert(pathinfo);
if (srv_util_pathisdir(pathinfo)) {
- if ( ((req->mode & LIB9P_O_MODE_MASK) != LIB9P_O_READ) ||
+ if ( ((req->mode & LIB9P_O_MODE_MASK) != LIB9P_O_MODE_READ) ||
(req->mode & LIB9P_O_TRUNC) ||
(req->mode & LIB9P_O_RCLOSE) ) {
lib9p_error(&ctx->ctx.basectx,
@@ -864,19 +864,19 @@ static void handle_Topen(struct _lib9p_srv_req *ctx,
uint8_t perm_bits = 0;
bool rd = false, wr = false;
switch (reqmode & LIB9P_O_MODE_MASK) {
- case LIB9P_O_READ:
+ case LIB9P_O_MODE_READ:
perm_bits = 0b100;
rd = true;
break;
- case LIB9P_O_WRITE:
+ case LIB9P_O_MODE_WRITE:
perm_bits = 0b010;
wr = true;
break;
- case LIB9P_O_RDWR:
+ case LIB9P_O_MODE_RDWR:
perm_bits = 0b110;
rd = wr = true;
break;
- case LIB9P_O_EXEC:
+ case LIB9P_O_MODE_EXEC:
perm_bits = 0b001;
rd = true;
break;
diff --git a/lib9p/tests/test_compile.c b/lib9p/tests/test_compile.c
index 6abee05..8f2445d 100644
--- a/lib9p/tests/test_compile.c
+++ b/lib9p/tests/test_compile.c
@@ -8,14 +8,26 @@ int main(void) {
x = LIB9P_DM_DIR;
x = LIB9P_DM_APPEND;
x = LIB9P_DM_EXCL;
- x = _LIB9P_DM_RESERVED_PLAN9_MOUNT;
+ x = _LIB9P_DM_PLAN9_MOUNT;
x = LIB9P_DM_AUTH;
x = LIB9P_DM_TMP;
+ x = _LIB9P_DM_UNUSED_25;
+ x = _LIB9P_DM_UNUSED_24;
x = LIB9P_DM_DEVICE;
- x = LIB9P_DM_NAMEDPIPE;
+ x = _LIB9P_DM_UNUSED_22;
+ x = LIB9P_DM_PIPE;
x = LIB9P_DM_SOCKET;
x = LIB9P_DM_SETUID;
x = LIB9P_DM_SETGID;
+ x = _LIB9P_DM_UNUSED_17;
+ x = _LIB9P_DM_UNUSED_16;
+ x = _LIB9P_DM_UNUSED_15;
+ x = _LIB9P_DM_UNUSED_14;
+ x = _LIB9P_DM_UNUSED_13;
+ x = _LIB9P_DM_UNUSED_12;
+ x = _LIB9P_DM_UNUSED_11;
+ x = _LIB9P_DM_UNUSED_10;
+ x = _LIB9P_DM_UNUSED_9;
x = LIB9P_DM_OWNER_R;
x = LIB9P_DM_OWNER_W;
x = LIB9P_DM_OWNER_X;
@@ -29,25 +41,38 @@ int main(void) {
x = LIB9P_QT_DIR;
x = LIB9P_QT_APPEND;
x = LIB9P_QT_EXCL;
- x = _LIB9P_QT_RESERVED_PLAN9_MOUNT;
+ x = _LIB9P_QT_PLAN9_MOUNT;
x = LIB9P_QT_AUTH;
x = LIB9P_QT_TMP;
x = LIB9P_QT_SYMLINK;
+ x = _LIB9P_QT_UNUSED_0;
x = LIB9P_QT_FILE;
x = LIB9P_NUID_NONUID;
+ x = _LIB9P_O_UNUSED_7;
x = LIB9P_O_RCLOSE;
x = _LIB9P_O_RESERVED_CEXEC;
x = LIB9P_O_TRUNC;
- x = _LIB9P_O_mode_1;
- x = _LIB9P_O_mode_0;
- x = LIB9P_O_READ;
- x = LIB9P_O_WRITE;
- x = LIB9P_O_RDWR;
- x = LIB9P_O_EXEC;
- x = LIB9P_O_MODE_MASK;
+ x = _LIB9P_O_UNUSED_3;
+ x = _LIB9P_O_UNUSED_2;
x = LIB9P_O_FLAG_MASK;
+ x = LIB9P_O_MODE_READ;
+ x = LIB9P_O_MODE_WRITE;
+ x = LIB9P_O_MODE_RDWR;
+ x = LIB9P_O_MODE_EXEC;
+ x = LIB9P_O_MODE_MASK;
x = LIB9P_ERRNO_NOERROR;
x = LIB9P_SUPER_MAGIC_V9FS_MAGIC;
+ x = _LIB9P_LO_UNUSED_31;
+ x = _LIB9P_LO_UNUSED_30;
+ x = _LIB9P_LO_UNUSED_29;
+ x = _LIB9P_LO_UNUSED_28;
+ x = _LIB9P_LO_UNUSED_27;
+ x = _LIB9P_LO_UNUSED_26;
+ x = _LIB9P_LO_UNUSED_25;
+ x = _LIB9P_LO_UNUSED_24;
+ x = _LIB9P_LO_UNUSED_23;
+ x = _LIB9P_LO_UNUSED_22;
+ x = _LIB9P_LO_UNUSED_21;
x = LIB9P_LO_SYNC;
x = LIB9P_LO_CLOEXEC;
x = LIB9P_LO_NOATIME;
@@ -63,27 +88,41 @@ int main(void) {
x = LIB9P_LO_NOCTTY;
x = LIB9P_LO_EXCL;
x = LIB9P_LO_CREATE;
- x = _LIB9P_LO_mode_1;
- x = _LIB9P_LO_mode_0;
- x = LIB9P_LO_RDONLY;
- x = LIB9P_LO_WRONLY;
- x = LIB9P_LO_RDWR;
- x = LIB9P_LO_NOACCESS;
- x = LIB9P_LO_MODE_MASK;
+ x = _LIB9P_LO_UNUSED_5;
+ x = _LIB9P_LO_UNUSED_4;
+ x = _LIB9P_LO_UNUSED_3;
+ x = _LIB9P_LO_UNUSED_2;
x = LIB9P_LO_FLAG_MASK;
+ x = LIB9P_LO_MODE_RDONLY;
+ x = LIB9P_LO_MODE_WRONLY;
+ x = LIB9P_LO_MODE_RDWR;
+ x = LIB9P_LO_MODE_NOACCESS;
+ x = LIB9P_LO_MODE_MASK;
x = LIB9P_DT_UNKNOWN;
- x = LIB9P_DT_NAMED_PIPE;
+ x = LIB9P_DT_PIPE;
x = LIB9P_DT_CHAR_DEV;
x = LIB9P_DT_DIRECTORY;
x = LIB9P_DT_BLOCK_DEV;
x = LIB9P_DT_REGULAR;
x = LIB9P_DT_SYMLINK;
x = LIB9P_DT_SOCKET;
- x = LIB9P_DT_WHITEOUT;
- x = _LIB9P_MODE_fmt_3;
- x = _LIB9P_MODE_fmt_2;
- x = _LIB9P_MODE_fmt_1;
- x = _LIB9P_MODE_fmt_0;
+ x = _LIB9P_DT_WHITEOUT;
+ x = _LIB9P_MODE_UNUSED_31;
+ x = _LIB9P_MODE_UNUSED_30;
+ x = _LIB9P_MODE_UNUSED_29;
+ x = _LIB9P_MODE_UNUSED_28;
+ x = _LIB9P_MODE_UNUSED_27;
+ x = _LIB9P_MODE_UNUSED_26;
+ x = _LIB9P_MODE_UNUSED_25;
+ x = _LIB9P_MODE_UNUSED_24;
+ x = _LIB9P_MODE_UNUSED_23;
+ x = _LIB9P_MODE_UNUSED_22;
+ x = _LIB9P_MODE_UNUSED_21;
+ x = _LIB9P_MODE_UNUSED_20;
+ x = _LIB9P_MODE_UNUSED_19;
+ x = _LIB9P_MODE_UNUSED_18;
+ x = _LIB9P_MODE_UNUSED_17;
+ x = _LIB9P_MODE_UNUSED_16;
x = LIB9P_MODE_PERM_SETGROUP;
x = LIB9P_MODE_PERM_SETUSER;
x = LIB9P_MODE_PERM_STICKY;
@@ -96,17 +135,67 @@ int main(void) {
x = LIB9P_MODE_PERM_OTHER_R;
x = LIB9P_MODE_PERM_OTHER_W;
x = LIB9P_MODE_PERM_OTHER_X;
- x = LIB9P_MODE_FMT_NAMED_PIPE;
+ x = LIB9P_MODE_PERM_MASK;
+ x = LIB9P_MODE_FMT_PIPE;
x = LIB9P_MODE_FMT_CHAR_DEV;
x = LIB9P_MODE_FMT_DIRECTORY;
x = LIB9P_MODE_FMT_BLOCK_DEV;
x = LIB9P_MODE_FMT_REGULAR;
x = LIB9P_MODE_FMT_SYMLINK;
x = LIB9P_MODE_FMT_SOCKET;
- x = LIB9P_MODE_PERM_MASK;
x = LIB9P_MODE_FMT_MASK;
x = LIB9P_B4_FALSE;
x = LIB9P_B4_TRUE;
+ x = _LIB9P_GETATTR_UNUSED_63;
+ x = _LIB9P_GETATTR_UNUSED_62;
+ x = _LIB9P_GETATTR_UNUSED_61;
+ x = _LIB9P_GETATTR_UNUSED_60;
+ x = _LIB9P_GETATTR_UNUSED_59;
+ x = _LIB9P_GETATTR_UNUSED_58;
+ x = _LIB9P_GETATTR_UNUSED_57;
+ x = _LIB9P_GETATTR_UNUSED_56;
+ x = _LIB9P_GETATTR_UNUSED_55;
+ x = _LIB9P_GETATTR_UNUSED_54;
+ x = _LIB9P_GETATTR_UNUSED_53;
+ x = _LIB9P_GETATTR_UNUSED_52;
+ x = _LIB9P_GETATTR_UNUSED_51;
+ x = _LIB9P_GETATTR_UNUSED_50;
+ x = _LIB9P_GETATTR_UNUSED_49;
+ x = _LIB9P_GETATTR_UNUSED_48;
+ x = _LIB9P_GETATTR_UNUSED_47;
+ x = _LIB9P_GETATTR_UNUSED_46;
+ x = _LIB9P_GETATTR_UNUSED_45;
+ x = _LIB9P_GETATTR_UNUSED_44;
+ x = _LIB9P_GETATTR_UNUSED_43;
+ x = _LIB9P_GETATTR_UNUSED_42;
+ x = _LIB9P_GETATTR_UNUSED_41;
+ x = _LIB9P_GETATTR_UNUSED_40;
+ x = _LIB9P_GETATTR_UNUSED_39;
+ x = _LIB9P_GETATTR_UNUSED_38;
+ x = _LIB9P_GETATTR_UNUSED_37;
+ x = _LIB9P_GETATTR_UNUSED_36;
+ x = _LIB9P_GETATTR_UNUSED_35;
+ x = _LIB9P_GETATTR_UNUSED_34;
+ x = _LIB9P_GETATTR_UNUSED_33;
+ x = _LIB9P_GETATTR_UNUSED_32;
+ x = _LIB9P_GETATTR_UNUSED_31;
+ x = _LIB9P_GETATTR_UNUSED_30;
+ x = _LIB9P_GETATTR_UNUSED_29;
+ x = _LIB9P_GETATTR_UNUSED_28;
+ x = _LIB9P_GETATTR_UNUSED_27;
+ x = _LIB9P_GETATTR_UNUSED_26;
+ x = _LIB9P_GETATTR_UNUSED_25;
+ x = _LIB9P_GETATTR_UNUSED_24;
+ x = _LIB9P_GETATTR_UNUSED_23;
+ x = _LIB9P_GETATTR_UNUSED_22;
+ x = _LIB9P_GETATTR_UNUSED_21;
+ x = _LIB9P_GETATTR_UNUSED_20;
+ x = _LIB9P_GETATTR_UNUSED_19;
+ x = _LIB9P_GETATTR_UNUSED_18;
+ x = _LIB9P_GETATTR_UNUSED_17;
+ x = _LIB9P_GETATTR_UNUSED_16;
+ x = _LIB9P_GETATTR_UNUSED_15;
+ x = _LIB9P_GETATTR_UNUSED_14;
x = LIB9P_GETATTR_DATA_VERSION;
x = LIB9P_GETATTR_GEN;
x = LIB9P_GETATTR_BTIME;
@@ -123,6 +212,29 @@ int main(void) {
x = LIB9P_GETATTR_MODE;
x = LIB9P_GETATTR_BASIC;
x = LIB9P_GETATTR_ALL;
+ x = _LIB9P_SETATTR_UNUSED_31;
+ x = _LIB9P_SETATTR_UNUSED_30;
+ x = _LIB9P_SETATTR_UNUSED_29;
+ x = _LIB9P_SETATTR_UNUSED_28;
+ x = _LIB9P_SETATTR_UNUSED_27;
+ x = _LIB9P_SETATTR_UNUSED_26;
+ x = _LIB9P_SETATTR_UNUSED_25;
+ x = _LIB9P_SETATTR_UNUSED_24;
+ x = _LIB9P_SETATTR_UNUSED_23;
+ x = _LIB9P_SETATTR_UNUSED_22;
+ x = _LIB9P_SETATTR_UNUSED_21;
+ x = _LIB9P_SETATTR_UNUSED_20;
+ x = _LIB9P_SETATTR_UNUSED_19;
+ x = _LIB9P_SETATTR_UNUSED_18;
+ x = _LIB9P_SETATTR_UNUSED_17;
+ x = _LIB9P_SETATTR_UNUSED_16;
+ x = _LIB9P_SETATTR_UNUSED_15;
+ x = _LIB9P_SETATTR_UNUSED_14;
+ x = _LIB9P_SETATTR_UNUSED_13;
+ x = _LIB9P_SETATTR_UNUSED_12;
+ x = _LIB9P_SETATTR_UNUSED_11;
+ x = _LIB9P_SETATTR_UNUSED_10;
+ x = _LIB9P_SETATTR_UNUSED_9;
x = LIB9P_SETATTR_MTIME_SET;
x = LIB9P_SETATTR_ATIME_SET;
x = LIB9P_SETATTR_CTIME;
@@ -135,6 +247,36 @@ int main(void) {
x = LIB9P_LOCK_TYPE_RDLCK;
x = LIB9P_LOCK_TYPE_WRLCK;
x = LIB9P_LOCK_TYPE_UNLCK;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_31;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_30;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_29;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_28;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_27;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_26;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_25;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_24;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_23;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_22;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_21;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_20;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_19;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_18;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_17;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_16;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_15;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_14;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_13;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_12;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_11;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_10;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_9;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_8;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_7;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_6;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_5;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_4;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_3;
+ x = _LIB9P_LOCK_FLAGS_UNUSED_2;
x = LIB9P_LOCK_FLAGS_RECLAIM;
x = LIB9P_LOCK_FLAGS_BLOCK;
x = LIB9P_LOCK_STATUS_SUCCESS;
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2025-04-05 20:47:50 +0000