add the sub-offset operator

doc/autogen/types/bytes.rst

@@ -92,6 +92,11 @@
     Returns the subsequence from the value's beginning to (but not
     including) *end*.
 
+.. spicy:method:: bytes::sub bytes sub False bytes (end: uint<64>)
+
+    Returns the subsequence from the value's beginning to (but not
+    including) offset *end*.
+
 .. spicy:method:: bytes::to_int bytes to_int False int<64> ([ base: uint<64> ])
 
     Interprets the data as representing an ASCII-encoded number and

doc/autogen/types/stream-view.rst

@@ -65,6 +65,12 @@
     Returns a new view of the subsequence from the beginning of the stream
     up to (but not including) *end*.
 
+.. spicy:method:: stream::view::sub view<stream> sub False view<stream> (end: uint<64>)
+
+    Returns a new view of the subsequence from the beginning of the view
+    to (but not including) offset *end*. The offset is relative to the
+    beginning of the view.
+
 .. rubric:: View Operators
 
 .. spicy:operator:: stream::view::Equal bool t:view<stream> <sp> op:== <sp> t:bytes $commutative$

hilti/toolchain/include/ast/forward.h

@@ -186,6 +186,7 @@ class Strip;
 class SubIterators;
 class SubIterator;
 class SubOffsets;
+class SubOffset;
 class Join;
 class ToIntAscii;
 class ToUIntAscii;
@@ -463,6 +464,7 @@ class StartsWith;
 class SubIterators;
 class SubIterator;
 class SubOffsets;
+class SubOffset;
 } // namespace view
 
 class Ctor;

hilti/toolchain/include/ast/node-tag.h

@@ -202,6 +202,7 @@ constexpr Tag ToUIntAscii = 930;
 constexpr Tag ToUIntBinary = 931;
 constexpr Tag Unequal = 932;
 constexpr Tag UpperCase = 933;
+constexpr Tag SubOffset = 934;
 
 namespace iterator {
 constexpr Tag Deref = 1000;
@@ -476,6 +477,7 @@ constexpr Tag SubIterators = 3314;
 constexpr Tag SubOffsets = 3315;
 constexpr Tag UnequalBytes = 3316;
 constexpr Tag UnequalView = 3317;
+constexpr Tag SubOffset = 3318;
 } // namespace view
 
 } // namespace stream

hilti/toolchain/include/ast/operators/bytes.h

@@ -45,6 +45,7 @@ HILTI_NODE_OPERATOR(bytes, Strip)
 HILTI_NODE_OPERATOR(bytes, SubIterators)
 HILTI_NODE_OPERATOR(bytes, SubIterator)
 HILTI_NODE_OPERATOR(bytes, SubOffsets)
+HILTI_NODE_OPERATOR(bytes, SubOffset)
 HILTI_NODE_OPERATOR(bytes, Join)
 HILTI_NODE_OPERATOR(bytes, ToIntAscii)
 HILTI_NODE_OPERATOR(bytes, ToUIntAscii)

hilti/toolchain/include/ast/operators/stream.h

@@ -41,6 +41,7 @@ HILTI_NODE_OPERATOR(stream::view, StartsWith)
 HILTI_NODE_OPERATOR(stream::view, SubIterators)
 HILTI_NODE_OPERATOR(stream::view, SubIterator)
 HILTI_NODE_OPERATOR(stream::view, SubOffsets)
+HILTI_NODE_OPERATOR(stream::view, SubOffset)
 HILTI_NODE_OPERATOR(stream, Ctor)
 HILTI_NODE_OPERATOR(stream, Size)
 HILTI_NODE_OPERATOR(stream, Unequal)

hilti/toolchain/include/ast/visitor-dispatcher.h

@@ -162,6 +162,7 @@ class Dispatcher {
     virtual void operator()(hilti::operator_::bytes::SubIterators*) {}
     virtual void operator()(hilti::operator_::bytes::SubIterator*) {}
     virtual void operator()(hilti::operator_::bytes::SubOffsets*) {}
+    virtual void operator()(hilti::operator_::bytes::SubOffset*) {}
     virtual void operator()(hilti::operator_::bytes::Join*) {}
     virtual void operator()(hilti::operator_::bytes::ToIntAscii*) {}
     virtual void operator()(hilti::operator_::bytes::ToUIntAscii*) {}
@@ -359,6 +360,7 @@ class Dispatcher {
     virtual void operator()(hilti::operator_::stream::view::SubIterators*) {}
     virtual void operator()(hilti::operator_::stream::view::SubIterator*) {}
     virtual void operator()(hilti::operator_::stream::view::SubOffsets*) {}
+    virtual void operator()(hilti::operator_::stream::view::SubOffset*) {}
     virtual void operator()(hilti::operator_::stream::Ctor*) {}
     virtual void operator()(hilti::operator_::stream::Size*) {}
     virtual void operator()(hilti::operator_::stream::Unequal*) {}

hilti/toolchain/src/ast/operators/bytes.cc

@@ -766,6 +766,31 @@ Returns the subsequence from offset *begin* to (but not including) offset *end*.
 };
 HILTI_OPERATOR_IMPLEMENTATION(SubOffsets);
 
+class SubOffset : public BuiltInMemberCall {
+public:
+    Signature signature(Builder* builder) const final {
+        return Signature{
+            .kind = Kind::MemberCall,
+            .self = {.kind = parameter::Kind::In, .type = builder->typeBytes()},
+            .member = "sub",
+            .param0 =
+                {
+                    .name = "end",
+                    .type = {.kind = parameter::Kind::In, .type = builder->typeUnsignedInteger(64)},
+                },
+            .result = {.constness = Constness::Const, .type = builder->typeBytes()},
+            .ns = "bytes",
+            .doc = R"(
+Returns the subsequence from the value's beginning to (but not including)
+offset *end*.
+)",
+        };
+    }
+
+    HILTI_OPERATOR(hilti, bytes::SubOffset);
+};
+HILTI_OPERATOR_IMPLEMENTATION(SubOffset);
+
 class Join : public BuiltInMemberCall {
 public:
     Signature signature(Builder* builder) const final {

hilti/toolchain/src/ast/operators/stream.cc

@@ -676,6 +676,32 @@ offset *end*. The offsets are relative to the beginning of the view.
 };
 HILTI_OPERATOR_IMPLEMENTATION(SubOffsets);
 
+class SubOffset : public BuiltInMemberCall {
+public:
+    Signature signature(Builder* builder) const final {
+        return Signature{
+            .kind = Kind::MemberCall,
+            .self = {.kind = parameter::Kind::In, .type = builder->typeStreamView()},
+            .member = "sub",
+            .param0 =
+                {
+                    .name = "end",
+                    .type = {.kind = parameter::Kind::In, .type = builder->typeUnsignedInteger(64)},
+                },
+            .result = {.constness = Constness::Const, .type = builder->typeStreamView()},
+            .ns = "stream::view",
+            .doc = R"(
+Returns a new view of the subsequence from the beginning of the view to (but
+not including) offset *end*. The offset is relative to the beginning of the
+view.
+)",
+        };
+    }
+
+    HILTI_OPERATOR(hilti, stream::view::SubOffset);
+};
+HILTI_OPERATOR_IMPLEMENTATION(SubOffset);
+
 } // namespace view
 
 class Ctor : public Operator {

hilti/toolchain/src/compiler/codegen/operators.cc

@@ -231,6 +231,11 @@ struct Visitor : hilti::visitor::PreOrder {
         result = fmt("%s.sub(%s, %s)", self, args[0], args[1]);
     }
 
+    void operator()(operator_::bytes::SubOffset* n) final {
+        auto [self, args] = methodArguments(n);
+        result = fmt("%s.sub(%s)", self, args[0]);
+    }
+
     void operator()(operator_::bytes::Join* n) final {
         auto [self, args] = methodArguments(n);
         result = fmt("%s.join(%s)", self, args[0]);
@@ -765,6 +770,11 @@ struct Visitor : hilti::visitor::PreOrder {
         result = fmt("%s.sub(%s, %s)", self, args[0], args[1]);
     }
 
+    void operator()(operator_::stream::view::SubOffset* n) final {
+        auto [self, args] = methodArguments(n);
+        result = fmt("%s.sub(%s)", self, args[0]);
+    }
+
     // Stream
 
     void operator()(operator_::stream::Size* n) final { result = fmt("%s.size()", op0(n)); }

tests/hilti/types/bytes/ops.hlt

@@ -44,6 +44,9 @@ assert y.find(b"890") == (False, y.at(8));
 
 global auto y2 = b"abcdedede";
 assert y2.sub(y2.find(b"def")[1], end(y2)) == b"de";
+assert y.sub(3) == b"012";
+assert y.sub(0) == b"";
+assert y.sub(|y|) == y;
 assert y.find(b"XYZ") == (False, end(y));
 assert (b"456" in y);
 assert ! (b"xyz" in y);
@@ -107,6 +110,7 @@ function void p(bytes x) {
     assert x <= b"bbc";
     assert (b"123" + x) == b"123abc";
     assert begin(x) == x.at(0);
+    assert x.sub(2) == b"ab";
     assert x.find(b"b") == (True, x.at(1));
     assert (b"b" in x);
     assert ! (b"X" in x);

tests/hilti/types/stream/view.hlt

@@ -27,6 +27,11 @@ assert ! v.starts_with(b"XYZ");
 
 assert |v| == 9;
 
+assert v.sub(3) == b"123";
+assert v.sub(0) == b"";
+assert v.sub(|v|) == b"123456789";
+assert all.sub(5) == b"01234";
+
 global stream x2 = stream(b"AbCdEf");
 v2 = cast<view<stream>>(x2).sub(x2.at(1), x2.at(5));
 

tests/spicy/types/bytes/operators.spicy

@@ -25,6 +25,8 @@ assert b"".split1() == (b"", b"");
 assert b"12".split1() == (b"12", b"");
 assert b"12 34 56 78".split1() == (b"12", b"34 56 78");
 assert b"12XX34XX56XX78".split1(b"XX") == (b"12", b"34XX56XX78");
+assert b"12345".sub(3) == b"123";
+assert b"12345".sub(0) == b"";
 assert b"xyz".starts_with(b"xy");
 assert ! b"xyz".starts_with(b"XY");
 assert b"  xyz  ".strip() == b"xyz";