AutoHotkey Community

 if (bufsize := GETbuf2(source, returnval) ) > 1
; returnval is byref
; return val filled via dll, basically memory moves.

{

if (substr(source,-3) = ".*$1") and  ((returnval5 := substr(returnval,1,5)) != badVtcID)
....

}

void BIF_SubStr(ExprTokenType &aResultToken, ExprTokenType *aParam[], int aParamCount) // Added in v1.0.46.
{
   // Set default return value in case of early return.
   aResultToken.symbol = SYM_STRING;
   aResultToken.marker = "";

   // Get the first arg, which is the string used as the source of the extraction. Call it "haystack" for clarity.
   char haystack_buf[MAX_NUMBER_SIZE]; // A separate buf because aResultToken.buf is sometimes used to store the result.
   char *haystack = TokenToString(*aParam[0], haystack_buf); // Remember that aResultToken.buf is part of a union, though in this case there's no danger of overwriting it since our result will always be of STRING type (not int or float).
   int haystack_length = (int)EXPR_TOKEN_LENGTH(aParam[0], haystack);

   // Load-time validation has ensured that at least the first two parameters are present:
   int starting_offset = (int)TokenToInt64(*aParam[1]) - 1; // The one-based starting position in haystack (if any).  Convert it to zero-based.
   if (starting_offset > haystack_length)
      return; // Yield the empty string (a default set higher above).
   if (starting_offset < 0) // Same convention as RegExMatch/Replace(): Treat a StartingPos of 0 (offset -1) as "start at the string's last char".  Similarly, treat negatives as starting further to the left of the end of the string.
   {
      starting_offset += haystack_length;
      if (starting_offset < 0)
         starting_offset = 0;
   }

   int remaining_length_available = haystack_length - starting_offset;
   int extract_length;
   if (aParamCount < 3) // No length specified, so extract all the remaining length.
      extract_length = remaining_length_available;
   else
   {
      if (   !(extract_length = (int)TokenToInt64(*aParam[2]))   )  // It has asked to extract zero characters.
         return; // Yield the empty string (a default set higher above).
      if (extract_length < 0)
      {
         extract_length += remaining_length_available; // Result is the number of characters to be extracted (i.e. after omitting the number of chars specified in extract_length).
         if (extract_length < 1) // It has asked to omit all characters.
            return; // Yield the empty string (a default set higher above).
      }
      else // extract_length > 0
         if (extract_length > remaining_length_available)
            extract_length = remaining_length_available;
   }

   // Above has set extract_length to the exact number of characters that will actually be extracted.
   char *result = haystack + starting_offset; // This is the result except for the possible need to truncate it below.

   if (extract_length == remaining_length_available) // All of haystack is desired (starting at starting_offset).
   {
      aResultToken.marker = result; // No need for any copying or termination, just send back part of haystack.
      return;                       // Caller and Var:Assign() know that overlap is possible, so this seems safe.
   }
   
   // Otherwise, at least one character is being omitted from the end of haystack.  So need a more complex method.
   if (extract_length <= MAX_NUMBER_LENGTH) // v1.0.46.01: Avoid malloc() for small strings.  However, this improves speed by only 10% in a test where random 25-byte strings were extracted from a 700 KB string (probably because VC++'s malloc()/free() are very fast for small allocations).
      aResultToken.marker = aResultToken.buf; // Store the address of the result for the caller.
   else
   {
      // Otherwise, validation higher above has ensured: extract_length < remaining_length_available.
      // Caller has provided a NULL circuit_token as a means of passing back memory we allocate here.
      // So if we change "result" to be non-NULL, the caller will take over responsibility for freeing that memory.
      if (   !(aResultToken.circuit_token = (ExprTokenType *)malloc(extract_length + 1))   ) // Out of memory. Due to rarity, don't display an error dialog (there's currently no way for a built-in function to abort the current thread anyway?)
         return; // Yield the empty string (a default set higher above).
      aResultToken.marker = (char *)aResultToken.circuit_token; // Store the address of the result for the caller.
      aResultToken.buf = (char *)(size_t)extract_length; // MANDATORY FOR USERS OF CIRCUIT_TOKEN: "buf" is being overloaded to store the length for our caller.
   }
   memcpy(aResultToken.marker, result, extract_length);
   aResultToken.marker[extract_length] = '\0'; // Must be done separately from the memcpy() because the memcpy() might just be taking a substring (i.e. long before result's terminator).
}

VarSetCapacity(pt,8)
VarSetCapacity(x,4,1), NumPut(33,x)
VarSetCapacity(y,4,1), NumPut(10,y)
pt .= x   ; This also appears to work:  pt := x . y
pt .= y
MsgBox % "pt: " pt "`nlength of pt: " StrLen(pt) "`npt@0: " NumGet(pt,0) "`npt@4: " NumGet(pt,4)

VarSetCapacity(x,4,1), NumPut(33,x)
VarSetCapacity(y,4,1), NumPut(10,y)
pt := x . y
MsgBox % "pt: '" pt "'`nlength of pt: " StrLen(pt) "`npt@0: " NumGet(pt,0) "`npt@4: " NumGet(pt,4)

VarSetCapacity(x,4,1), NumPut(33,x)
VarSetCapacity(y,4,1), NumPut(10,y)
F(x . y)        ; Null-terminated, passes the bytes: 33, 0.
F(_ := x . y)   ; Uses length of _ (length of x + length of y).

F(pt) {
    MsgBox % "pt: '" pt "'`nlength of pt: " StrLen(pt) "`npt@0: " NumGet(pt,0) "`npt@4: " NumGet(pt,4)
}