democracy 0.0.56

data/server_creator/code

@@ -0,0 +1,510 @@
+function m() {
+	main_func = "";
+  all_code = "";
+  if (11 || cpp) {
+    decl = "const ";
+  }
+  VERBOSE_DEBUG = this.global && process.env["DEBUG"] == "true";
+  function get_all_declarations() {
+    return ((this.global && process.env["DECLS"]) || "").split(/,,/);
+  }
+  g = 0;
+  const javascript = process["mode"] === "js";
+  const cpp=process["mode"] === "cpp";
+  javascript || cpp || alert("Error, no mode selected");
+  if (cpp) {
+    decl = "const ";
+    decl_int = "size_t ";
+    array_decl = "Array   &                       ";
+    precode = `
+
+    #define function static inline void*
+    #define var auto
+    #define let auto
+    #define const const auto
+    `;
+  } else {
+    array_decl = decl = decl_int = "";
+    precode = `
+function set_globals() {
+nesting=0;VERBOSE_DEBUG=${VERBOSE_DEBUG};puts=console.warn
+}                        ;       set_globals();         `;
+  } /*
+	if (javascript)*/
+  if (cpp) {
+    len = "array.size()";
+  } else {
+    len = "array.length";
+  }
+  const m = (func, array, cond, one, i = [0, len]) => {
+    func = func.split(".").join("_");
+    c = "";
+    if (cpp) {
+      c += `#ifndef ${func}_macro
+		#define ${func}_macro
+		#undef ${func}
+		#undef ${func}_otherwise
+		#ifndef nop_func_macro
+		#define nop_func_macro
+		static double *  nop_func(...) { return nullptr; }
+		#endif
+		#define ${func}_otherwise nop_func`;
+    }
+    c += precode + `function ${func}(${array_decl} array, ${decl_int} i) {`;
+    if (javascript)
+      c += `if (typeof(array) === "string") {
+          try {
+        array =    [...document.querySelectorAll(array)];
+        } catch (e) {
+        }}`;
+    c += `
+    	${cpp?"double*":      "var"} rvalue;
+        ${
+          this.global &&
+          get_all_declarations().map((i) => {
+            if (!i.trim()) return "";
+            return "/* DECL */   const " + i;
+          })
+        }
+        ${VERBOSE_DEBUG ? ++nesting : ""};
+        const max = ${i[1]};
+        while (i < max) {
+               Type element = array[i];
+               
+               const v = element;
+               const value = element;
+  `;
+    if (javascript) {
+      c += `const style = element.style`;
+    }
+    c += `                ${
+      VERBOSE_DEBUG
+        ? 'console.warn(" ".repeat((nesting - 1) * 4) + `....Iteration ${i} i=` + [i, "/", max, " (", Math.round(i/max*100, 2), "%", ") +", 1.0/max*100, "%", " of loop completed"].join(""))'
+        : ""
+    }
+                const condition = ${cond};
+                if (condition) {
+                		using namespace std;
+                        rvalue = ${cpp ? "*(double**)(size_t)(size_t*)&(" : ""}${one}${
+      cpp ? ")" : ""
+    };
+                } else {`;
+    if (javascript) {
+      c += "try    {         ";
+    }
+    c += `
+                        rvalue = ${func}_otherwise(${cpp ? "&(" : "["}element${
+      cpp ? ")" : "]"
+    }, 0);
+`;
+    if (javascript)
+      c += `
+                        } catch (e) {}`;
+    c;
+    c += `   }  ++i; } `;
+    if (VERBOSE_DEBUG && javascript)
+      c += `
+        console.warn("Loop comp");
+        --nesting;`;
+    c += `
+return rvalue;
+}
+`;
+    if (cpp) {
+      c += `#endif` + "\n";
+    }
+{
+    }
+
+    if (!func.endsWith("otherwise")) {
+    	d = main_func;
+    	if (cpp) {
+    		function    pr(i) {
+    			if (i.match(/^[0-9]+$/)) {
+    				return i + "ll";
+    			}
+
+    			return i;
+
+    			}
+    			
+    		    	d += '{';
+    		d += `Array   a\n\t{\n\t${       array.slice(1).split("]")[0].split(",").map((i) =>     { return "c("+pr(i.trim())+")"}  ).join(",\n\t")}\n\t};\n`;
+
+			const methods = array.split("]")[1].trim();
+			if (methods.length != 0) {
+				d += 'a';
+				d +=methods;
+				d += ";\n";}
+    		    	d += `${func}(a, ${i[0]}); \n  return 0; }`               ;
+    	} else {
+    		d += `${func}(${array}, ${i[0]})`;
+    	}
+    	main_func = d
+}
+    function to_s(e) {
+      return e;
+    }
+    function to_ss(e) {
+      console.warn("Element is '" + e + "'");
+      try {
+        return JSON.stringify(ev+al(e)).toString();
+      } catch (_) {
+        return typeof e === "string" ? e : JSON.stringify(e);
+      }
+    }
+  };
+  args = "";
+  try {
+    args = process.argv.slice(2).join(",,");
+  } catch (_) {
+    args = [...arguments].join(",,");
+  }
+  if (!args) {
+    console.clear();
+    console.warn("Added m function and env function");
+    return;
+  }
+  args = args.split(",,");
+  for (var i = 0; i < args.length; ) {
+    s = args.slice(i, i + 4);
+    if (s[0].match(/otherwise$/)) {
+      s = [s[0], [true], true, s[1]];
+      i += 2;
+    } else {
+      i += 4;
+    }
+    m(...s);
+    foo(s[0], c);
+    all_code += c;
+  }
+  all_code += `
+  function ${prog_name = "e" + Date.now()}_main() {
+  	${main_func}
+  }`
+  if (cpp)
+  	all_code = cpp_pre_code() + all_code + `\n\n\nint main() {   ${prog_name}_main(); }`
+  else
+  	all_code+="\n"+prog_name+"_main();";
+  foo("all_code", all_code);
+  if (javascript) {
+  	try {
+  		eval(all_code);
+  	} catch (e) {
+  		console.warn(e);
+  	}
+  }
+  if (VERBOSE_DEBUG) {
+    console.log(all_code);
+  }
+  function foo(func, code) {
+    const out = `${func}.${process.mode}`;
+    try {
+      require("fs").writeFileSync(out, code);
+    } catch (_) {
+      var saveData = (function () {
+        var a = document.createElement("a");
+        document.body.appendChild(a);
+        a.style = "display: none";
+        return function (data, fileName) {
+          var json = data,
+            blob = new Blob([json], { type: "octet/stream" }),
+            url = window.URL.createObjectURL(blob);
+          a.href = url;
+          a.download = fileName;
+          a.click();
+          window.URL.revokeObjectURL(url);
+        };
+      })();
+      saveData(code, out);
+    }
+  }
+  console.warn(all_code);
+  return true;
+}
+
+env("mode", "js", 1) && m() && env("mode", "cpp", 1) && m();
+function env(a, b,mode) {
+  var n = this.global || window;
+  n.process = n.process || { env: { DEBUG: "true", DECLS: "" } };
+
+  if (!mode) {
+	  process.env.DECLS += `${a}=${b},,`;
+	 } else { process[a] = b; }
+  return true;
+}
+function help() {
+  console.table(`m() (Browser console and node) -> generates a list of all arguments (or strings separted by double commas)
+Functions are run sequentially. Otherwise functions are not run.
+All functions loop over something
+All functions have a conditional.
+func_name iterable (such as a list or a DOMElement) condition expression
+The resultant function returns the last expression in the function
+This isn't a DSL, it's extremely broad.
+Any algorithm can be expressed this way.
+This makes writing algorithms much, much easier.
+It works in Node.js and in the browser.
+After generating all functions, the resultant code gets downloaded.
+`);
+}
+
+
+function cpp_pre_code() {
+
+return `
+
+
+
+
+#include <cstddef>
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <cstring>
+
+enum {INT, DOUBLE, STRING, VECTOR} Types;
+
+#define c construct
+
+class Type {
+public:
+	double type, *value, refs;
+
+operator std::string();
+void print();
+};
+
+
+
+template <class A>
+class Array_sub : public std::vector<A>
+{
+public:
+
+
+
+inline std::string to_s_(const Type val_) {
+
+	if (val_.type == STRING) {
+		return *(const char**)&val_.value;
+	}
+	if (val_.type == INT) {
+		return std::to_string((long long 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}
+	{}
+	
+	inline void push(A value) {
+		std::vector<A>::emplace_back(value);
+	}
+
+	~Array_sub() {
+		for ( Type& i: *this) {
+				if (i.refs) {
+					--i.refs;
+				free(i.value);
+				}
+			}
+	}
+	
+
+
+	inline Array_sub<A>& operator<< (A v) {
+		push(v);
+		return *this;
+	}
+
+/*	void append() {
+	}
+
+	append_all() {
+		std::for_each(i.begin(), i.end(), append);
+	}*/
+
+	Type
+	construct(char* const a, const double    refs) { return Type{2, (double*)a, refs}; }
+
+
+	inline auto surround(const char* first=nullptr, const char* second=nullptr) {
+
+		typedef Array_sub<Type> Array;
+		Array b{};
+		for (size_t i = 0; i < this->size(); ++i) {
+			std::string s{first};
+			s += to_s_((*this)[i]);
+			s += second;
+			
+			b.push(c(strdup(s.c_str()), 1));
+		}
+		return b;
+	}
+
+	inline auto js() {
+		return surround("<script type='text/javascript'>", "</script>");
+	}
+	
+	operator std::string() {
+		return to_s();
+	}
+
+	inline auto append(const char* arg1) {
+		return surround(nullptr, arg1);
+	}
+
+	
+	inline auto prepend(const char* arg1) {
+		return surround(nullptr, arg1);
+	}
+
+	inline auto quote() {
+		return surround("'", "'");
+	}
+
+	inline auto join(const char* delim) {
+		std::string result;
+		const auto length=this->size();
+		for (size_t i = 0; i < length; ++i) {
+			result += (*this)[i];
+			if (i==length-1) {
+			} else {
+				result += delim;
+			}
+		}
+
+		return result;
+	}
+
+	inline auto html(const std::string title="Application")  const {
+		return surround(\"<!DOCTYPE html><html><head><meta charset='utf-8'/ ><title>\" + title + \"</head><body>\", \"</body></html>\");
+	}
+	
+	inline auto p() {
+		return surround("<p>", "</p>");
+	}
+
+	inline auto div() {
+		return surround("<div>", "</div>");
+	}
+
+	inline auto nls() {
+		return surround(nullptr, "\\n");
+	}
+
+
+	
+	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<Type> Array;
+
+
+
+
+Type::operator std::string()     {
+	const Type& val_ = *this;
+
+	if (val_.type == STRING) {
+		return *(const char**)&val_.value;
+	}
+	if (val_.type == INT) {
+		return std::to_string((long long int)val_.value);
+	}
+	if (val_.type == DOUBLE) {
+		const size_t a = *(long long*)&val_.value;
+		return std::to_string((double)a);
+	}
+
+	if (val_.type == VECTOR) {
+		return (*(Array       **)(&val_.value))->to_s();
+	}
+
+	std::cout << "Error";
+	exit(1);
+};
+
+void puts(std::string a) {
+	puts(a.c_str());
+}
+
+void Type::print() {
+	puts(((std::string)(*this)).c_str());
+}
+Type construct(const long long int a) { return Type{0, (double*)a,0}; }
+
+
+Type construct(Array a) {return
+ Type{3,       *(double**)&a,0};
+
+}
+Type operator ""_c(unsigned long long a) {
+	return c(a);
+}
+
+Type construct(const double a) {
+	return Type{1,        *(double**)&a, 0};
+
+}
+
+Type construct(const char* const a, const double refs=0) { return Type{2, (double*)a, refs}; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+`;
+
+}

data/server_creator/make_application

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+clear
+
+
+./test.sh
+#sudo true
+
+if [ $USER = root ]; then true; else sudo -p "Enter password > " $0  $USER  | red; exit 0; fi
+
+the_config_file=/usr/share/nginx/nginx.conf
+
+which spawn-fcgi > /dev/null || sudo apt-get install libfcgi-dev spawn-fcgi nginx   curl
+
+
+
+echo '
+
+events {
+  worker_connections 1024;
+}
+
+http {
+  server {
+    listen 80;
+    server_name localhost;
+
+    location / {
+      fastcgi_pass   127.0.0.1:8000;
+
+      fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
+      fastcgi_param  SERVER_SOFTWARE    nginx;
+      fastcgi_param  QUERY_STRING       $query_string;
+      fastcgi_param  REQUEST_METHOD     $request_method;
+      fastcgi_param  CONTENT_TYPE       $content_type;
+      fastcgi_param  CONTENT_LENGTH     $content_length;
+      fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;
+      fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
+      fastcgi_param  REQUEST_URI        $request_uri;
+      fastcgi_param  DOCUMENT_URI       $document_uri;
+      fastcgi_param  DOCUMENT_ROOT      $document_root;
+      fastcgi_param  SERVER_PROTOCOL    $server_protocol;
+      fastcgi_param  REMOTE_ADDR        $remote_addr;
+      fastcgi_param  REMOTE_PORT        $remote_port;
+      fastcgi_param  SERVER_ADDR        $server_addr;
+      fastcgi_param  SERVER_PORT        $server_port;
+      fastcgi_param  SERVER_NAME        $server_name;
+    }
+  }
+}
+'>$the_config_file
+
+
+killall nginx apache2 spawn-fcgi a.out -9 &>/dev/null
+
+
+nginx -c $the_config_file
+node program.js prog '[1, [1, [2, 3]], [4, 5], [3, 4], [[2]]]' 1 'element.print()' || die
+g++ -O3 -static -Wall -Wextra -s all_code.cpp -lfcgi -lfcgi++ -O3 -s -Wall -Wextra
+
+# spawn the fcgi app on port 8000 with no fork
+spawn-fcgi -p 8000 -n a.out &
+sudo su -c 'google-chrome http://localhost:80 &>/dev/null &' -- $1     &
+#reset

data/server_creator/prog.cpp

@@ -0,0 +1,33 @@
+#ifndef prog_macro
+		#define prog_macro
+		#undef prog
+		#undef prog_otherwise
+		#ifndef nop_func_macro
+		#define nop_func_macro
+		static double* nop_func(...) { return nullptr; }
+		#endif
+		#define prog_otherwise nop_func
+
+    #define function static inline void*
+    #define var auto
+    #define let auto
+    #define const const auto
+    function prog(Array array, size_t i) {double *  rvalue
+        
+        ;
+        const max = array.size();
+        while (i < max) {
+               Object element = array[i];
+                  
+                const condition = 1;
+                if (condition) {
+                		using namespace std;
+                		
+                		//{one.slice(one.length - 1)
+                        rvalue = *(double**)(size_t)(size_t*)&(element.print());
+                } else {
+                        rvalue = prog_otherwise(&(element), 0);
+   }  ++i; } 
+return rvalue;
+}
+#endif

data/server_creator/prog.js

@@ -0,0 +1,22 @@
+
+function set_globals() {
+nesting=0;VERBOSE_DEBUG=false;function puts() { eval("return con" + "sole" + ".warn"); }
+}                        ;       set_globals();         function prog( array,  i) {var rvalue
+        
+        ;
+        const max = array.length;
+        while (i < max) {
+               Object element = array[i];
+  const style = element.style                
+                const condition = 1;
+                if (condition) {
+                		using namespace std;
+                		
+                		//{one.slice(one.length - 1)
+                        rvalue = element.print();
+                } else {try    {         
+                        rvalue = prog_otherwise([element], 0);
+
+                        } catch (e) {}   }  ++i; } 
+return rvalue;
+}