democracy 0.0.56

data/q.cpp

@@ -0,0 +1,175 @@
+#include <cstddef>
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <string.h>
+
+enum {INT, DOUBLE, STRING, VECTOR};
+const char* types[] = {"int", "double", "string", "vector"};
+
+typedef struct {
+	double type;
+	double value;
+} Type;
+
+
+
+template <class A>
+class Array_sub : public std::vector<A>
+{
+void free_all(int num) {
+	for (int i = 0; i < num; ++i) {
+		delete &((*this)[i][-1]);
+	}
+}
+
+inline std::string to_s_(const double* const a) {
+	const Type& val_ = (Type&)*(a - 1);
+
+	if (val_.type == STRING) {
+		return *(const char**)&val_.value;
+	}
+	if (val_.type == INT) {
+		return std::to_string((int)val_.value);
+	}
+	if (val_.type == DOUBLE) {
+		return std::to_string((double)val_.value);
+	}
+
+	if (val_.type == VECTOR) {
+		return (*(Array_sub<A>**)(&val_.value))->to_s();
+	}
+
+	std::cout << "Error";
+	exit(1);
+	
+}
+
+public:
+	Array_sub(std::initializer_list<A> a) : std::vector<A>{a}
+	{}
+	~Array_sub()
+	{free_all(this->size());}
+	
+	inline void push(A value) {
+		std::vector<A>::emplace_back(value);
+	}
+
+//	append_all(
+	inline Array_sub<A>& operator<< (A v) {
+		push(v);
+		return *this;
+	}
+
+/*	void append() {
+	}
+
+	append_all() {
+		std::for_each(i.begin(), i.end(), append);
+	}*/
+
+	double* construct(const char* a) { Type* const tp = new Type{2, *(double*)&a}; return &tp->value; }
+	auto prepend(std::string arg) {
+		typedef Array_sub<double*> Array;
+		
+		Array* b = new Array{};
+		for (size_t i = 0; i < this->size(); ++i) {
+			puts((to_s_((*this)[i]) + arg).c_str());
+//			auto a = new s
+			std::string* q  = new std::string{to_s_(arg + (*this)[i])};
+			b->push(this->construct(q->c_str()));
+		}
+		return *b;
+	}
+	
+	auto append(std::string arg) {
+		typedef Array_sub<double*> Array;
+		
+		Array* b = new Array{};
+		for (size_t i = 0; i < this->size(); ++i) {
+			puts((to_s_((*this)[i]) + arg).c_str());
+//			auto a = new s
+			std::string* q  = new std::string{to_s_((*this)[i]) + arg};
+			b->push(this->construct(q->c_str()));
+		}
+		return *b;
+	}
+	auto surround(std::string arg, std::string a) {
+		typedef Array_sub<double*> Array;
+		
+		Array* b = new Array{};
+		for (size_t i = 0; i < this->size(); ++i) {
+			//puts((to_s_((*this)[i]) + arg).c_str());
+//			auto a = new s
+			std::string* q  = new std::string{arg + to_s_((*this)[i]) + a};
+			b->push(this->construct(q->c_str()));
+		}
+		return *b;
+	}
+	
+	operator std::string() {
+		return to_s();
+	}
+
+	
+	std::string to_s() {
+		std::ostringstream str;
+		str << "[";
+	for (size_t  i = 0; i < this->size(); ++i) {
+		str << to_s_((*this)[i]);
+
+		if (i == this->size() - 1) {
+		} else {
+			str << ", ";
+		}
+	}
+		str << "]";
+
+
+
+return str.str();
+
+}
+};
+typedef Array_sub<double*> Array;
+
+#define c construct
+
+double* construct(const long long int a) { Type* const tp = new Type{0, (double)a}; return &tp->value; }
+
+double* construct(std::string a) { Type* const tp = new Type{2, *(double*)&a}; return &tp->value; }
+double* construct(const char* a) { Type* const tp = new Type{2, *(double*)&a}; return &tp->value; }
+
+double* construct(Array* a) {
+	Type* const tp = new Type{3, *(double*)&a};
+return &tp->value;
+
+}
+double* operator ""_c(unsigned long long a) {
+	return (double*)c(a);
+}
+double* operator ""_s(const char* a) {
+	return (double*)c(std::string(a));
+}
+
+double* construct(const double a) {
+	Type* const tp = new Type{1, *(double*)&a}; return &tp->value;
+
+}
+
+
+#define TIMES(MAX) for (int temp_ = 0; temp_ < MAX; ++temp_)
+
+
+int main(int argc,   char** argv) {
+	Array array{};
+	TIMES(argc)
+
+	{
+		array.push(c(argv[temp_]));
+	}
+
+//	array.push(5_c);
+//	array.append_all("foo");
+	std::cout << (std::string)(array.surround("'", "'")) << '\n';
+}

data/qt/.qmake.stash

@@ -0,0 +1,23 @@
+QMAKE_CXX.QT_COMPILER_STDCXX = 201402L
+QMAKE_CXX.QMAKE_GCC_MAJOR_VERSION = 9
+QMAKE_CXX.QMAKE_GCC_MINOR_VERSION = 3
+QMAKE_CXX.QMAKE_GCC_PATCH_VERSION = 0
+QMAKE_CXX.COMPILER_MACROS = \
+    QT_COMPILER_STDCXX \
+    QMAKE_GCC_MAJOR_VERSION \
+    QMAKE_GCC_MINOR_VERSION \
+    QMAKE_GCC_PATCH_VERSION
+QMAKE_CXX.INCDIRS = \
+    /usr/include/c++/9 \
+    /usr/include/x86_64-linux-gnu/c++/9 \
+    /usr/include/c++/9/backward \
+    /usr/lib/gcc/x86_64-linux-gnu/9/include \
+    /usr/local/include \
+    /usr/include/x86_64-linux-gnu \
+    /usr/include
+QMAKE_CXX.LIBDIRS = \
+    /usr/lib/gcc/x86_64-linux-gnu/9 \
+    /usr/lib/x86_64-linux-gnu \
+    /usr/lib \
+    /lib/x86_64-linux-gnu \
+    /lib

data/qt/a.cpp

@@ -0,0 +1,39 @@
+// g++ -fPIC -O3 -s *.cpp $(pkg-config --cflags --libs `pkg-config --list-all | fgrep Qt | cut -f 1 -d ' ' | xargs`) && ./a.out 
+
+#include <QWebSettings>
+#include <QStandardPaths>
+#include <QtGui>
+#include <QLabel>
+#include <QApplication>
+#include <QMainWindow>
+#include <QDockWidget>
+#include <QtWebKit>
+#include <QWebView>
+#include <QHBoxLayout>
+#include <QWindow>
+int main(int argc, char** argv) {
+QApplication app(argc, argv);
+QWebView view;
+QWebSettings *d = QWebSettings::globalSettings();
+//using QWebSettings;
+d->setAttribute(QWebSettings::JavascriptEnabled, true);
+d->setAttribute(QWebSettings::JavascriptCanOpenWindows, true);
+d->setAttribute(QWebSettings::JavascriptCanCloseWindows, true);
+d->setAttribute(QWebSettings::JavascriptCanAccessClipboard, true);
+
+d->setAttribute(QWebSettings::AutoLoadImages, true);
+
+
+d->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
+d->setAttribute(QWebSettings::PluginsEnabled, true);
+//  app.setStyleSheet("* { color: blue; background-color: blue; border-radius: 40px; opacity: 0.4; }");
+view.load(QUrl("http://ethicify.online"));
+QDockWidget window;
+window.setFeatures(QDockWidget::AllDockWidgetFeatures);
+window.setTitleBarWidget(&view);
+window.resize(600, 200);
+//window.setOpacity(0.8);
+window.show();
+window.windowHandle()->setOpacity(0.8);
+return app.exec();
+}

data/qt/a.sh

@@ -0,0 +1,7 @@
+for file in stdio stdlib unistd  ; do
+echo "#include <${file}.h>";
+
+done
+
+
+echo 'int main() {chdir("C:\\Windows\\Temp"); '                                 ;                 for i in prog *.dll ; do xxd -i $i | gsub 'unsigned' 'static const   ' ; a=`echo $i | tr '[[:punct:]]'   '_'`  ;     echo               "FILE* ${a}_file = fopen(          \"${i}\", \"wb\");"               ;                                                                                                                                                                                                                                     echo                                                                           "         fwrite(${a},                             ${a}_len, 1, ${a}_file); fclose(${a}_file);  "     ; notify-send ${a};   done; echo 'system("start prog");                 ; }';

data/qt/prog

@@ -0,0 +1 @@
+Hello

data/quickjs/.git/HEAD

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

data/quickjs/.git/config

@@ -0,0 +1,11 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[remote "origin"]
+	url = https://github.com/bellard/quickjs.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master

data/quickjs/.git/description

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

data/quickjs/.git/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+"$@"}
+:

data/quickjs/.git/hooks/commit-msg.sample

@@ -0,0 +1,24 @@
+#!/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.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

data/quickjs/.git/hooks/fsmonitor-watchman.sample

@@ -0,0 +1,109 @@
+#!/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 1) and a time in nanoseconds
+# formatted as a string and outputs to stdout all files that have been
+# modified since the given time. 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, $time) = @ARGV;
+
+# Check the hook interface version
+
+if ($version == 1) {
+	# convert nanoseconds to seconds
+	# subtract one second to make sure watchman will return all changes
+	$time = int ($time / 1000000000) - 1;
+} else {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree;
+if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+	$git_work_tree = Win32::GetCwd();
+	$git_work_tree =~ tr/\\/\//;
+} else {
+	require Cwd;
+	$git_work_tree = Cwd::cwd();
+}
+
+my $retry = 1;
+
+launch_watchman();
+
+sub launch_watchman {
+
+	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 $time but were not transient (ie created after
+	# $time but no longer exist).
+	#
+	# 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.
+
+	my $query = <<"	END";
+		["query", "$git_work_tree", {
+			"since": $time,
+			"fields": ["name"]
+		}]
+	END
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	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 =~ /^\{/;
+
+	my $json_pkg;
+	eval {
+		require JSON::XS;
+		$json_pkg = "JSON::XS";
+		1;
+	} or do {
+		require JSON::PP;
+		$json_pkg = "JSON::PP";
+	};
+
+	my $o = $json_pkg->new->utf8->decode($response);
+
+	if ($retry > 0 and $o->{error} and $o->{error} =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		print STDERR "Adding '$git_work_tree' to watchman's watch list.\n";
+		$retry--;
+		qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+
+		# 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.
+		print "/\0";
+		eval { launch_watchman() };
+		exit 0;
+	}
+
+	die "Watchman: $o->{error}.\n" .
+	    "Falling back to scanning...\n" if $o->{error};
+
+	binmode STDOUT, ":utf8";
+	local $, = "\0";
+	print @{$o->{files}};
+}

data/quickjs/.git/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

data/quickjs/.git/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+"$@"}
+:

data/quickjs/.git/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 --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 --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 --

data/quickjs/.git/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"
+:

data/quickjs/.git/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 sha1> <remote ref> <remote sha1>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+z40=0000000000000000000000000000000000000000
+
+while read local_ref local_sha remote_ref remote_sha
+do
+	if [ "$local_sha" = $z40 ]
+	then
+		# Handle delete
+		:
+	else
+		if [ "$remote_sha" = $z40 ]
+		then
+			# New branch, examine all commits
+			range="$local_sha"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_sha..$local_sha"
+		fi
+
+		# Check for WIP commit
+		commit=`git rev-list -n 1 --grep '^WIP' "$range"`
+		if [ -n "$commit" ]
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0