* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
- * along with this program; if not, write to the *
- * Free Software Foundation, Inc., *
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
if ((sq == 0) && (dq == 0) && (lq == 0)) {
for (i = 0; i < lb; i++)
*dst++ = *src++;
- return (uint8_t *)_dst;
+ return _dst;
}
/* fallback to slow bit copy */
}
}
- return (uint8_t *)_dst;
+ return _dst;
}
uint32_t flip_u32(uint32_t value, unsigned int num)
}
}
- const char *DIGITS = "0123456789ABCDEF";
+ const char * const DIGITS = "0123456789ABCDEF";
for (unsigned j = 0; j < str_len; j++)
str[j] = DIGITS[(int)str[j]];
return str;
}
-/* / identify radix, and skip radix-prefix (0, 0x or 0X) */
+/** identify radix, and skip radix-prefix (0, 0x or 0X) */
static void str_radix_guess(const char **_str, unsigned *_str_len,
unsigned *_radix)
{
return i;
}
+
+void bit_copy_queue_init(struct bit_copy_queue *q)
+{
+ INIT_LIST_HEAD(&q->list);
+}
+
+int bit_copy_queued(struct bit_copy_queue *q, uint8_t *dst, unsigned dst_offset, const uint8_t *src,
+ unsigned src_offset, unsigned bit_count)
+{
+ struct bit_copy_queue_entry *qe = malloc(sizeof(*qe));
+ if (!qe)
+ return ERROR_FAIL;
+
+ qe->dst = dst;
+ qe->dst_offset = dst_offset;
+ qe->src = src;
+ qe->src_offset = src_offset;
+ qe->bit_count = bit_count;
+ list_add_tail(&qe->list, &q->list);
+
+ return ERROR_OK;
+}
+
+void bit_copy_execute(struct bit_copy_queue *q)
+{
+ struct bit_copy_queue_entry *qe;
+ struct bit_copy_queue_entry *tmp;
+ list_for_each_entry_safe(qe, tmp, &q->list, list) {
+ bit_copy(qe->dst, qe->dst_offset, qe->src, qe->src_offset, qe->bit_count);
+ list_del(&qe->list);
+ free(qe);
+ }
+}
+
+void bit_copy_discard(struct bit_copy_queue *q)
+{
+ struct bit_copy_queue_entry *qe;
+ struct bit_copy_queue_entry *tmp;
+ list_for_each_entry_safe(qe, tmp, &q->list, list) {
+ list_del(&qe->list);
+ free(qe);
+ }
+}
+
+/**
+ * Convert a string of hexadecimal pairs into its binary
+ * representation.
+ *
+ * @param[out] bin Buffer to store binary representation. The buffer size must
+ * be at least @p count.
+ * @param[in] hex String with hexadecimal pairs to convert into its binary
+ * representation.
+ * @param[in] count Number of hexadecimal pairs to convert.
+ *
+ * @return The number of converted hexadecimal pairs.
+ */
+size_t unhexify(uint8_t *bin, const char *hex, size_t count)
+{
+ size_t i;
+ char tmp;
+
+ if (!bin || !hex)
+ return 0;
+
+ memset(bin, 0, count);
+
+ for (i = 0; i < 2 * count; i++) {
+ if (hex[i] >= 'a' && hex[i] <= 'f')
+ tmp = hex[i] - 'a' + 10;
+ else if (hex[i] >= 'A' && hex[i] <= 'F')
+ tmp = hex[i] - 'A' + 10;
+ else if (hex[i] >= '0' && hex[i] <= '9')
+ tmp = hex[i] - '0';
+ else
+ return i / 2;
+
+ bin[i / 2] |= tmp << (4 * ((i + 1) % 2));
+ }
+
+ return i / 2;
+}
+
+int hexify(char *hex, const char *bin, int count, int out_maxlen)
+{
+ int i, cmd_len = 0;
+
+ /* May use a length, or a null-terminated string as input. */
+ if (count == 0)
+ count = strlen(bin);
+
+ for (i = 0; i < count; i++)
+ cmd_len += snprintf(hex + cmd_len, out_maxlen - cmd_len, "%02x", bin[i] & 0xff);
+
+ return cmd_len;
+}
+
+void buffer_shr(void *_buf, unsigned buf_len, unsigned count)
+{
+ unsigned i;
+ unsigned char *buf = _buf;
+ unsigned bytes_to_remove;
+ unsigned shift;
+
+ bytes_to_remove = count / 8;
+ shift = count - (bytes_to_remove * 8);
+
+ for (i = 0; i < (buf_len - 1); i++)
+ buf[i] = (buf[i] >> shift) | ((buf[i+1] << (8 - shift)) & 0xff);
+
+ buf[(buf_len - 1)] = buf[(buf_len - 1)] >> shift;
+
+ if (bytes_to_remove) {
+ memmove(buf, &buf[bytes_to_remove], buf_len - bytes_to_remove);
+ memset(&buf[buf_len - bytes_to_remove], 0, bytes_to_remove);
+ }
+}