Tag-Filter hinzugefügt

.gitignore

@@ -1 +1,2 @@
 build/
+uartscope-git/

include/mainwindow.h

@@ -15,6 +15,7 @@
 #include "tableview.h"
 #include "tagwidget.h"
 #include "connectdialog.h"
+#include <QSet>
 
 class MainWindow : public QMainWindow
 {
@@ -35,6 +36,7 @@ private slots:
     void onNewLine(const QString &line);
     void onTagDetected(const QString &tag, const QString &value);
     void showFormatReference();
+    void configureTagFilter();
 
 private:
     void setupUi();
@@ -64,5 +66,6 @@ private:
     QAction *m_connectAction    = nullptr;
     QAction *m_disconnectAction = nullptr;
 
-    SerialConfig m_lastConfig;
+    SerialConfig    m_lastConfig;
+    QSet<QString>   m_suppressedTags;   // tags hidden from Raw view
 };

include/rawview.h

@@ -8,13 +8,13 @@
 #include <QCheckBox>
 #include <QLabel>
 #include <QSpinBox>
+#include <QRegularExpression>
 
 // RawView shows the raw UART output in a QPlainTextEdit with:
-//  - Configurable maximum line count (default: unlimited / very large)
-//  - Auto-scroll that pauses when the user scrolls up
-//  - Horizontal scroll (word wrap off)
-//  - Incremental text search
-//  - Clear button
+//  - Timestamp prefix on every line (hh:mm:ss.zzz)
+//  - Configurable tag suppression (lines whose tag is in the filter set are hidden)
+//  - Unlimited history, H+V scrolling, incremental search
+//  - Copy-to-clipboard and Clear buttons
 class RawView : public QWidget
 {
     Q_OBJECT
@@ -23,13 +23,15 @@ public:
     explicit RawView(QWidget *parent = nullptr);
 
 public slots:
-    void appendLine(const QString &line);
+    // suppressedTags: set of uppercase tag names whose lines should NOT appear here
+    void appendLine(const QString &line, const QSet<QString> &suppressedTags = {});
     void clear();
 
 private slots:
     void onSearch(const QString &text);
     void onScrollValueChanged(int value);
     void onAutoScrollToggled(bool enabled);
+    void copyToClipboard();
 
 private:
     void setupUi();
@@ -38,8 +40,11 @@ private:
     QPlainTextEdit *m_textEdit     = nullptr;
     QLineEdit      *m_searchEdit   = nullptr;
     QPushButton    *m_clearBtn     = nullptr;
+    QPushButton    *m_copyBtn      = nullptr;
     QCheckBox      *m_autoScrollCb = nullptr;
     QLabel         *m_lineCountLbl = nullptr;
     bool            m_autoScroll   = true;
     int             m_lineCount    = 0;
+
+    static const QRegularExpression s_tagRe;
 };

include/tagpanel.h

@@ -1,17 +1,16 @@
 #pragma once
-#include <QWidget>
 #include <QGroupBox>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
-#include <QDateTime>
-#include <QList>
-#include <QPair>
+#include <QPushButton>
 #include <QTableWidget>
+#include <QStringList>
 
-// TagPanel displays the most recent data associated with a single tag (e.g. [WDG]).
-// Values are parsed as key=value pairs, or shown as a raw string if no '=' is found.
-// Example input line:  [WDG] uptime=1234 temp=42.1 load=0.8
+// TagPanel displays the most recent data for a single tag (e.g. [WDG]).
+// Key=value pairs are shown in a table that updates in-place.
+// A "Copy" button copies the current values to the clipboard.
+// No timestamp is shown here – timestamps belong in the Raw view.
 class TagPanel : public QGroupBox
 {
     Q_OBJECT
@@ -24,14 +23,16 @@ public:
 public slots:
     void update(const QString &value);
 
+private slots:
+    void copyToClipboard();
+
 private:
     void parseKeyValue(const QString &value);
     void showRaw(const QString &value);
     void ensureRow(const QString &key);
 
     QString       m_tag;
-    QTableWidget *m_table      = nullptr;
-    QLabel       *m_rawLabel   = nullptr;
-    QLabel       *m_timestampLabel = nullptr;
-    QStringList   m_keys;   // ordered list for row lookup
+    QTableWidget *m_table    = nullptr;
+    QLabel       *m_rawLabel = nullptr;
+    QStringList   m_keys;
 };

src/mainwindow.cpp

@@ -124,6 +124,13 @@ void MainWindow::setupToolBar()
 
     tb->addSeparator();
 
+    // ── Tag filter ────────────────────────────────────────────────────────────
+    auto *filterAction = tb->addAction(tr("Tag filter…"));
+    filterAction->setToolTip(tr("Choose which tags are hidden from the Raw view"));
+    connect(filterAction, &QAction::triggered, this, &MainWindow::configureTagFilter);
+
+    tb->addSeparator();
+
     // ── Format reference ──────────────────────────────────────────────────────
     auto *helpAction = tb->addAction(tr("Format reference"));
     helpAction->setToolTip(tr("Show UARTScope output format guide (copy for AI)"));
@@ -231,7 +238,7 @@ void MainWindow::onError(const QString &message)
 
 void MainWindow::onNewLine(const QString &line)
 {
-    m_rawView->appendLine(line);
+    m_rawView->appendLine(line, m_suppressedTags);
     m_tableView->appendLine(line);
 }
 
@@ -392,3 +399,48 @@ void uart_status_update(void) {
     dlg->exec();
     dlg->deleteLater();
 }
+
+// ── Tag filter dialog ──────────────────────────────────────────────────────
+
+void MainWindow::configureTagFilter()
+{
+    auto *dlg = new QDialog(this);
+    dlg->setWindowTitle(tr("Tag filter – Raw view"));
+    dlg->setMinimumWidth(340);
+
+    auto *layout = new QVBoxLayout(dlg);
+
+    auto *infoLabel = new QLabel(
+        tr("Tags listed here are <b>hidden from the Raw view</b> and only "
+           "appear in the Tag Monitor panel.<br>"
+           "Enter one tag name per line, without brackets (e.g. <tt>WDG</tt>)."), dlg);
+    infoLabel->setWordWrap(true);
+    layout->addWidget(infoLabel);
+
+    auto *edit = new QPlainTextEdit(dlg);
+    QFont mono("Monospace");
+    mono.setStyleHint(QFont::Monospace);
+    edit->setFont(mono);
+    // Pre-populate with current filter
+    QStringList current(m_suppressedTags.values());
+    current.sort();
+    edit->setPlainText(current.join('\n'));
+    layout->addWidget(edit, 1);
+
+    auto *btnBox = new QDialogButtonBox(
+        QDialogButtonBox::Ok | QDialogButtonBox::Cancel, dlg);
+    connect(btnBox, &QDialogButtonBox::accepted, dlg, &QDialog::accept);
+    connect(btnBox, &QDialogButtonBox::rejected, dlg, &QDialog::reject);
+    layout->addWidget(btnBox);
+
+    if (dlg->exec() == QDialog::Accepted) {
+        m_suppressedTags.clear();
+        const QStringList lines = edit->toPlainText().split('\n', Qt::SkipEmptyParts);
+        for (const QString &line : lines) {
+            const QString tag = line.trimmed().toUpper();
+            if (!tag.isEmpty())
+                m_suppressedTags.insert(tag);
+        }
+    }
+    dlg->deleteLater();
+}

src/rawview.cpp

@@ -5,6 +5,11 @@
 #include <QFont>
 #include <QPalette>
 #include <QApplication>
+#include <QClipboard>
+#include <QDateTime>
+
+const QRegularExpression RawView::s_tagRe(
+    R"(\[([A-Z][A-Z0-9_]*)\])", QRegularExpression::CaseInsensitiveOption);
 
 RawView::RawView(QWidget *parent)
     : QWidget(parent)
@@ -15,7 +20,7 @@ RawView::RawView(QWidget *parent)
 
 void RawView::setupUi()
 {
-    auto *mainLayout   = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     mainLayout->setContentsMargins(4, 4, 4, 4);
     mainLayout->setSpacing(4);
 
@@ -23,7 +28,7 @@ void RawView::setupUi()
     auto *toolbar = new QHBoxLayout();
 
     m_searchEdit = new QLineEdit(this);
-    m_searchEdit->setPlaceholderText(tr("Search…  (Enter)"));
+    m_searchEdit->setPlaceholderText(tr("Search…"));
     m_searchEdit->setClearButtonEnabled(true);
     connect(m_searchEdit, &QLineEdit::textChanged, this, &RawView::onSearch);
 
@@ -31,33 +36,35 @@ void RawView::setupUi()
     m_autoScrollCb->setChecked(true);
     connect(m_autoScrollCb, &QCheckBox::toggled, this, &RawView::onAutoScrollToggled);
 
-    m_clearBtn = new QPushButton(tr("Clear"), this);
-    connect(m_clearBtn, &QPushButton::clicked, this, &RawView::clear);
-
     m_lineCountLbl = new QLabel(tr("Lines: 0"), this);
     m_lineCountLbl->setMinimumWidth(90);
 
+    m_copyBtn = new QPushButton(tr("📋 Copy"), this);
+    m_copyBtn->setToolTip(tr("Copy all raw output to clipboard"));
+    connect(m_copyBtn, &QPushButton::clicked, this, &RawView::copyToClipboard);
+
+    m_clearBtn = new QPushButton(tr("Clear"), this);
+    connect(m_clearBtn, &QPushButton::clicked, this, &RawView::clear);
+
     toolbar->addWidget(new QLabel(tr("Search:"), this));
     toolbar->addWidget(m_searchEdit, 1);
     toolbar->addWidget(m_autoScrollCb);
     toolbar->addWidget(m_lineCountLbl);
+    toolbar->addWidget(m_copyBtn);
     toolbar->addWidget(m_clearBtn);
     mainLayout->addLayout(toolbar);
 
-    // ── Text area ────────────────────────────────────────────────────────────
+    // ── Text area ─────────────────────────────────────────────────────────────
     m_textEdit = new QPlainTextEdit(this);
     m_textEdit->setReadOnly(true);
-    m_textEdit->setLineWrapMode(QPlainTextEdit::NoWrap);   // horizontal scroll
-    // Practically unlimited history (Qt uses a block count limit internally)
-    m_textEdit->setMaximumBlockCount(0);  // 0 = unlimited
+    m_textEdit->setLineWrapMode(QPlainTextEdit::NoWrap);
+    m_textEdit->setMaximumBlockCount(0);  // unlimited
 
-    // Monospaced font for alignment
     QFont monoFont("Monospace");
     monoFont.setStyleHint(QFont::Monospace);
     monoFont.setPointSize(10);
     m_textEdit->setFont(monoFont);
 
-    // Don't let the text edit swallow horizontal scroll events from the viewport
     m_textEdit->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     m_textEdit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
@@ -69,31 +76,48 @@ void RawView::setupUi()
 
 void RawView::applyColorScheme()
 {
-    // Dark terminal style
     QPalette p = m_textEdit->palette();
-    p.setColor(QPalette::Base,  QColor(0x1e, 0x1e, 0x1e));
-    p.setColor(QPalette::Text,  QColor(0xd4, 0xd4, 0xd4));
+    p.setColor(QPalette::Base, QColor(0x1e, 0x1e, 0x1e));
+    p.setColor(QPalette::Text, QColor(0xd4, 0xd4, 0xd4));
     m_textEdit->setPalette(p);
 }
 
-void RawView::appendLine(const QString &line)
+void RawView::appendLine(const QString &line, const QSet<QString> &suppressedTags)
 {
+    // Check whether this line belongs to a suppressed tag
+    if (!suppressedTags.isEmpty()) {
+        const auto match = s_tagRe.match(line);
+        if (match.hasMatch()) {
+            if (suppressedTags.contains(match.captured(1).toUpper()))
+                return;   // silently drop – it goes to the Tag Monitor only
+        }
+    }
+
     ++m_lineCount;
     m_lineCountLbl->setText(tr("Lines: %1").arg(m_lineCount));
 
-    // Highlight lines that contain a tag like [WDG]
-    static const QRegularExpression tagRe(R"(\[[A-Z][A-Z0-9_]*\])",
-                                          QRegularExpression::CaseInsensitiveOption);
-    if (tagRe.match(line).hasMatch()) {
-        // Append as HTML so we can colour it differently
-        QTextCursor cursor(m_textEdit->document());
-        cursor.movePosition(QTextCursor::End);
-        QTextCharFormat fmt;
-        fmt.setForeground(QColor(0x56, 0xb6, 0xc2));  // cyan-ish
-        cursor.insertText(line + '\n', fmt);
-    } else {
-        m_textEdit->appendPlainText(line);
-    }
+    // Prepend timestamp
+    const QString ts = QDateTime::currentDateTime().toString("hh:mm:ss.zzz");
+    const QString displayLine = QStringLiteral("[%1]  %2").arg(ts, line);
+
+    // Colour tag lines cyan, everything else default
+    const bool hasTag = s_tagRe.match(line).hasMatch();
+
+    QTextCursor cursor(m_textEdit->document());
+    cursor.movePosition(QTextCursor::End);
+
+    QTextCharFormat fmt;
+    if (hasTag)
+        fmt.setForeground(QColor(0x56, 0xb6, 0xc2));  // cyan
+    else
+        fmt.setForeground(QColor(0xd4, 0xd4, 0xd4));  // default
+
+    // Dim the timestamp portion
+    QTextCharFormat tsFmt;
+    tsFmt.setForeground(QColor(0x60, 0x60, 0x60));
+
+    cursor.insertText(QStringLiteral("[%1]  ").arg(ts), tsFmt);
+    cursor.insertText(line + '\n', fmt);
 
     if (m_autoScroll)
         m_textEdit->verticalScrollBar()->setValue(
@@ -107,9 +131,13 @@ void RawView::clear()
     m_lineCountLbl->setText(tr("Lines: 0"));
 }
 
+void RawView::copyToClipboard()
+{
+    QApplication::clipboard()->setText(m_textEdit->toPlainText());
+}
+
 void RawView::onSearch(const QString &text)
 {
-    // Simple incremental search – highlight first match
     QTextDocument *doc = m_textEdit->document();
     QTextCursor cursor = doc->find(text);
     if (!cursor.isNull()) {
@@ -124,9 +152,7 @@ void RawView::onSearch(const QString &text)
 
 void RawView::onScrollValueChanged(int value)
 {
-    const int max = m_textEdit->verticalScrollBar()->maximum();
-    // If user scrolled away from bottom, disable auto-scroll
-    if (value < max - 5) {
+    if (value < m_textEdit->verticalScrollBar()->maximum() - 5) {
         m_autoScroll = false;
         m_autoScrollCb->setChecked(false);
     }

src/tagpanel.cpp

@@ -1,21 +1,18 @@
 #include "tagpanel.h"
 #include <QHeaderView>
 #include <QRegularExpression>
+#include <QApplication>
+#include <QClipboard>
 
 TagPanel::TagPanel(const QString &tag, QWidget *parent)
     : QGroupBox(QStringLiteral("[%1]").arg(tag), parent)
     , m_tag(tag)
 {
     auto *layout = new QVBoxLayout(this);
-    layout->setContentsMargins(6, 12, 6, 6);
+    layout->setContentsMargins(6, 14, 6, 6);
     layout->setSpacing(4);
 
-    // Timestamp line
-    m_timestampLabel = new QLabel(tr("No data yet"), this);
-    m_timestampLabel->setStyleSheet("color: gray; font-size: 10px;");
-    layout->addWidget(m_timestampLabel);
-
-    // Table for key=value pairs
+    // ── Table for key=value pairs ─────────────────────────────────────────────
     m_table = new QTableWidget(0, 2, this);
     m_table->setHorizontalHeaderLabels({tr("Key"), tr("Value")});
     m_table->horizontalHeader()->setStretchLastSection(true);
@@ -26,23 +23,28 @@ TagPanel::TagPanel(const QString &tag, QWidget *parent)
     m_table->verticalHeader()->setDefaultSectionSize(22);
     layout->addWidget(m_table);
 
-    // Fallback label for non-kv data
+    // ── Fallback label for non-kv data ────────────────────────────────────────
     m_rawLabel = new QLabel(this);
     m_rawLabel->setWordWrap(true);
     m_rawLabel->setStyleSheet("font-family: monospace;");
     m_rawLabel->hide();
     layout->addWidget(m_rawLabel);
+
+    // ── Copy button ───────────────────────────────────────────────────────────
+    auto *btnRow = new QHBoxLayout();
+    btnRow->addStretch();
+    auto *copyBtn = new QPushButton(tr("📋 Copy"), this);
+    copyBtn->setToolTip(tr("Copy current tag values to clipboard"));
+    copyBtn->setMaximumWidth(90);
+    connect(copyBtn, &QPushButton::clicked, this, &TagPanel::copyToClipboard);
+    btnRow->addWidget(copyBtn);
+    layout->addLayout(btnRow);
 }
 
 void TagPanel::update(const QString &value)
 {
-    m_timestampLabel->setText(
-        QDateTime::currentDateTime().toString("hh:mm:ss.zzz"));
-
-    // Detect key=value format: word=anything (space separated)
     static const QRegularExpression kvRe(R"((\w+)=(\S+))");
-    auto it = kvRe.globalMatch(value);
-    if (it.hasNext()) {
+    if (kvRe.match(value).hasMatch()) {
         parseKeyValue(value);
         m_rawLabel->hide();
         m_table->show();
@@ -59,13 +61,10 @@ void TagPanel::parseKeyValue(const QString &value)
     auto it = kvRe.globalMatch(value);
     while (it.hasNext()) {
         const auto match = it.next();
-        const QString key = match.captured(1);
-        const QString val = match.captured(2);
-        ensureRow(key);
-        const int row = m_keys.indexOf(key);
-        m_table->item(row, 1)->setText(val);
-        // Flash highlight
-        m_table->item(row, 1)->setBackground(QColor(0x2d, 0x5a, 0x2d));
+        ensureRow(match.captured(1));
+        const int row = m_keys.indexOf(match.captured(1));
+        m_table->item(row, 1)->setText(match.captured(2));
+        m_table->item(row, 1)->setBackground(QColor(0x2d, 0x5a, 0x2d));  // flash green
     }
 }
 
@@ -84,3 +83,21 @@ void TagPanel::ensureRow(const QString &key)
     m_table->setItem(row, 0, new QTableWidgetItem(key));
     m_table->setItem(row, 1, new QTableWidgetItem(QString()));
 }
+
+void TagPanel::copyToClipboard()
+{
+    QStringList lines;
+    lines << QStringLiteral("[%1]").arg(m_tag);
+
+    if (m_table->isVisible()) {
+        for (int r = 0; r < m_table->rowCount(); ++r) {
+            const QString key = m_table->item(r, 0)->text();
+            const QString val = m_table->item(r, 1)->text();
+            lines << QStringLiteral("  %1 = %2").arg(key, val);
+        }
+    } else {
+        lines << QStringLiteral("  %1").arg(m_rawLabel->text());
+    }
+
+    QApplication::clipboard()->setText(lines.join('\n'));
+}

uartscope-git/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: diabolus <your@email.com>
 pkgname=uartscope
-pkgver=1.0.0
+pkgver=1.0.0.r0.gcc102c9
 pkgrel=1
 pkgdesc="Qt6-based UART serial monitor with tag monitoring, table view and auto-reconnect"
 arch=('x86_64' 'aarch64')

uartscope-git/pkg/uartscope/.PKGINFO

@@ -0,0 +1,19 @@
+# Generated by makepkg 7.1.0
+# using fakeroot version 1.38.1
+pkgname = uartscope
+pkgbase = uartscope
+xdata = pkgtype=pkg
+pkgver = 1.0.0.r0.gcc102c9-1
+pkgdesc = Qt6-based UART serial monitor with tag monitoring, table view and auto-reconnect
+url = https://git.projekt-hirnfrei.de/diabolus/uartscope
+builddate = 1780954815
+packager = Unknown Packager
+size = 176146
+arch = x86_64
+license = MIT
+conflict = uartscope
+provides = uartscope
+depend = qt6-base
+depend = qt6-serialport
+makedepend = cmake
+makedepend = git

uartscope-git/pkg/uartscope/usr/share/applications/uartscope.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=UARTScope
+Comment=UART Serial Monitor
+Exec=uartscope
+Icon=utilities-terminal
+Terminal=false
+Type=Application
+Categories=Development;Utility;

uartscope-git/uartscope/FETCH_HEAD

@@ -0,0 +1,2 @@
+cc102c93eb17f7b910d8e74c3505f198bed77f10	not-for-merge	branch 'main' of https://git.projekt-hirnfrei.de/diabolus/uartscope
+cc102c93eb17f7b910d8e74c3505f198bed77f10	not-for-merge	tag 'v1.0.0' of https://git.projekt-hirnfrei.de/diabolus/uartscope

uartscope-git/uartscope/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/main

uartscope-git/uartscope/config

@@ -0,0 +1,9 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = true
+[remote "origin"]
+	url = https://git.projekt-hirnfrei.de/diabolus/uartscope.git
+	tagOpt = --no-tags
+	fetch = +refs/*:refs/*
+	mirror = true

uartscope-git/uartscope/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

uartscope-git/uartscope/hooks/applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

uartscope-git/uartscope/hooks/commit-msg.sample

@@ -0,0 +1,74 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines and messages that
+# would confuse 'git am'.
+
+ret=0
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	ret=1
+}
+
+comment_re="$(
+	{
+		git config --get-regexp "^core\.comment(char|string)\$" ||
+			echo '#'
+	} | sed -n -e '
+		${
+			s/^[^ ]* //
+			s|[][*./\]|\\&|g
+			s/^auto$/[#;@!$%^&|:]/
+			p
+		}'
+)"
+scissors_line="^${comment_re} -\{8,\} >8 -\{8,\}\$"
+comment_line="^${comment_re}.*"
+blank_line='^[ 	]*$'
+# Disallow lines starting with "diff -" or "Index: " in the body of the
+# message. Stop looking if we see a scissors line.
+line="$(sed -n -e "
+	# Skip comments and blank lines at the start of the file.
+	/${scissors_line}/q
+	/${comment_line}/d
+	/${blank_line}/d
+	# The first paragraph will become the subject header so
+	# does not need to be checked.
+	: subject
+	n
+	/${scissors_line}/q
+	/${blank_line}/!b subject
+	# Check the body of the message for problematic
+	# prefixes.
+	: body
+	n
+	/${scissors_line}/q
+	/${comment_line}/b body
+	/^diff -/{p;q;}
+	/^Index: /{p;q;}
+	b body
+	" "$1")"
+if test -n "$line"
+then
+	echo >&2 "Message contains a diff that will confuse 'git am'."
+	echo >&2 "To fix this indent the diff."
+	ret=1
+fi
+
+exit $ret

uartscope-git/uartscope/hooks/fsmonitor-watchman.sample

@@ -0,0 +1,168 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $o->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

uartscope-git/uartscope/hooks/post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

uartscope-git/uartscope/hooks/pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

uartscope-git/uartscope/hooks/pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

uartscope-git/uartscope/hooks/pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

uartscope-git/uartscope/hooks/pre-push.sample

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

uartscope-git/uartscope/hooks/pre-rebase.sample

@@ -0,0 +1,169 @@
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up to date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

uartscope-git/uartscope/hooks/pre-receive.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to make use of push options.
+# The example simply echoes all push options that start with 'echoback='
+# and rejects all pushes when the "reject" push option is used.
+#
+# To enable this hook, rename this file to "pre-receive".
+
+if test -n "$GIT_PUSH_OPTION_COUNT"
+then
+	i=0
+	while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"
+	do
+		eval "value=\$GIT_PUSH_OPTION_$i"
+		case "$value" in
+		echoback=*)
+			echo "echo from the pre-receive-hook: ${value#*=}" >&2
+			;;
+		reject)
+			exit 1
+		esac
+		i=$((i + 1))
+	done
+fi

uartscope-git/uartscope/hooks/prepare-commit-msg.sample

@@ -0,0 +1,42 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples. The first one removes the
+# "# Please enter the commit message..." help message.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE"
+
+# case "$COMMIT_SOURCE,$SHA1" in
+#  ,|template,)
+#    /usr/bin/perl -i.bak -pe '
+#       print "\n" . `git diff --cached --name-status -r`
+# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
+#  *) ;;
+# esac
+
+# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
+# if test -z "$COMMIT_SOURCE"
+# then
+#   /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE"
+# fi

uartscope-git/uartscope/hooks/push-to-checkout.sample

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+# An example hook script to update a checked-out tree on a git push.
+#
+# This hook is invoked by git-receive-pack(1) when it reacts to git
+# push and updates reference(s) in its repository, and when the push
+# tries to update the branch that is currently checked out and the
+# receive.denyCurrentBranch configuration variable is set to
+# updateInstead.
+#
+# By default, such a push is refused if the working tree and the index
+# of the remote repository has any difference from the currently
+# checked out commit; when both the working tree and the index match
+# the current commit, they are updated to match the newly pushed tip
+# of the branch. This hook is to be used to override the default
+# behaviour; however the code below reimplements the default behaviour
+# as a starting point for convenient modification.
+#
+# The hook receives the commit with which the tip of the current
+# branch is going to be updated:
+commit=$1
+
+# It can exit with a non-zero status to refuse the push (when it does
+# so, it must not modify the index or the working tree).
+die () {
+	echo >&2 "$*"
+	exit 1
+}
+
+# Or it can make any necessary changes to the working tree and to the
+# index to bring them to the desired state when the tip of the current
+# branch is updated to the new commit, and exit with a zero status.
+#
+# For example, the hook can simply run git read-tree -u -m HEAD "$1"
+# in order to emulate git fetch that is run in the reverse direction
+# with git push, as the two-tree form of git read-tree -u -m is
+# essentially the same as git switch or git checkout that switches
+# branches while keeping the local changes in the working tree that do
+# not interfere with the difference between the branches.
+
+# The below is a more-or-less exact translation to shell of the C code
+# for the default behaviour for git's push-to-checkout hook defined in
+# the push_to_deploy() function in builtin/receive-pack.c.
+#
+# Note that the hook will be executed from the repository directory,
+# not from the working tree, so if you want to perform operations on
+# the working tree, you will have to adapt your code accordingly, e.g.
+# by adding "cd .." or using relative paths.
+
+if ! git update-index -q --ignore-submodules --refresh
+then
+	die "Up-to-date check failed"
+fi
+
+if ! git diff-files --quiet --ignore-submodules --
+then
+	die "Working directory has unstaged changes"
+fi
+
+# This is a rough translation of:
+#
+#   head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX
+if git cat-file -e HEAD 2>/dev/null
+then
+	head=HEAD
+else
+	head=$(git hash-object -t tree --stdin </dev/null)
+fi
+
+if ! git diff-index --quiet --cached --ignore-submodules $head --
+then
+	die "Working directory has staged changes"
+fi
+
+if ! git read-tree -u -m "$commit"
+then
+	die "Could not update working tree to new HEAD"
+fi

uartscope-git/uartscope/hooks/sendemail-validate.sample

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+# An example hook script to validate a patch (and/or patch series) before
+# sending it via email.
+#
+# The hook should exit with non-zero status after issuing an appropriate
+# message if it wants to prevent the email(s) from being sent.
+#
+# To enable this hook, rename this file to "sendemail-validate".
+#
+# By default, it will only check that the patch(es) can be applied on top of
+# the default upstream branch without conflicts in a secondary worktree. After
+# validation (successful or not) of the last patch of a series, the worktree
+# will be deleted.
+#
+# The following config variables can be set to change the default remote and
+# remote ref that are used to apply the patches against:
+#
+#   sendemail.validateRemote (default: origin)
+#   sendemail.validateRemoteRef (default: HEAD)
+#
+# Replace the TODO placeholders with appropriate checks according to your
+# needs.
+
+validate_cover_letter () {
+	file="$1"
+	# TODO: Replace with appropriate checks (e.g. spell checking).
+	true
+}
+
+validate_patch () {
+	file="$1"
+	# Ensure that the patch applies without conflicts.
+	git am -3 "$file" || return
+	# TODO: Replace with appropriate checks for this patch
+	# (e.g. checkpatch.pl).
+	true
+}
+
+validate_series () {
+	# TODO: Replace with appropriate checks for the whole series
+	# (e.g. quick build, coding style checks, etc.).
+	true
+}
+
+# main -------------------------------------------------------------------------
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = 1
+then
+	remote=$(git config --default origin --get sendemail.validateRemote) &&
+	ref=$(git config --default HEAD --get sendemail.validateRemoteRef) &&
+	worktree=$(mktemp --tmpdir -d sendemail-validate.XXXXXXX) &&
+	git worktree add -fd --checkout "$worktree" "refs/remotes/$remote/$ref" &&
+	git config --replace-all sendemail.validateWorktree "$worktree"
+else
+	worktree=$(git config --get sendemail.validateWorktree)
+fi || {
+	echo "sendemail-validate: error: failed to prepare worktree" >&2
+	exit 1
+}
+
+unset GIT_DIR GIT_WORK_TREE
+cd "$worktree" &&
+
+if grep -q "^diff --git " "$1"
+then
+	validate_patch "$1"
+else
+	validate_cover_letter "$1"
+fi &&
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL"
+then
+	git config --unset-all sendemail.validateWorktree &&
+	trap 'git worktree remove -ff "$worktree"' EXIT &&
+	validate_series
+fi

uartscope-git/uartscope/hooks/update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

uartscope-git/uartscope/info/attributes

@@ -0,0 +1 @@
+* -export-subst -export-ignore

uartscope-git/uartscope/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

uartscope-git/uartscope/packed-refs

@@ -0,0 +1,2 @@
+# pack-refs with: peeled fully-peeled sorted 
+cc102c93eb17f7b910d8e74c3505f198bed77f10 refs/heads/main

uartscope-git/uartscope/refs/tags/v1.0.0

@@ -0,0 +1 @@
+cc102c93eb17f7b910d8e74c3505f198bed77f10