democracy 0.0.56

data/program.prog

@@ -0,0 +1,568 @@
+function m() {
+	main_func = "";decl="const";
+  all_code = "";
+  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};function puts() { eval("return con" + "sole" + ".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`;
+    }
+    var new_one = [];
+
+    one = one.split(/\s*;\s*/);
+    for (const i of one)
+    {
+    	if (i.length) {
+	    	new_one.push(i + ';');
+	    }
+    }
+    one = new_one;
+    c += precode + `function ${func}(${array_decl} array, ${decl_int} i) {`;
+    c += `${cpp?"double*":      "var"} rvalue`;
+ //       }}`;
+    c += `
+        ${
+          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) {
+               Object element = array[i];
+               
+               const v = element;
+               const value = element;
+  `;
+    if (javascript) {
+      c += `const style = element.style`;
+    }
+    c += `                ${
+      VERBOSE_DEBUG
+        ? 'puts(" ".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;
+                		${one.slice(0, one.length - 1).join("\n\t\t\t\t")}
+                		//{one.slice(one.length - 1)
+                        rvalue = ${cpp ? "*(double**)(size_t)(size_t*)&(" : ""}${(last = one[one.length - 1]).substr(0,last.length - 1)}${
+      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 += `
+        puts("Loop comp");
+        --nesting;`;
+    c += `
+return rvalue;
+}
+`;
+    if (cpp) {
+      c += `#endif` + "\n";
+    }
+{
+    }
+function  remove_sides(a, first, last) {
+	if (a.startsWith(first))
+		a =  a.slice(first.length, a.length);
+    	if (a.endsWith(last)) {
+    		a = a.slice(0,a.length-last.length);}  return a;}
+
+ /*   String.prototype.gsub = function*/
+
+    if (!func.endsWith("otherwise")) {
+    	d = main_func;
+    	if (cpp) {try { array = mod(JSON.parse(array)); }
+ catch (e) { console.warn(e);process.exit() };
+ d += 'return \n';
+
+ d += `${func}(\n${array},\n${i[0]}\n);`;
+    	}
+    	main_func = d
+}
+    function to_s(e) {
+      return e;
+    }
+    
+  };
+  args = "";
+  try {
+    args = process.argv.slice(2).join(",,");
+  } catch (_) {
+    args = [...arguments].join(",,");
+  }
+  if (!args) {
+    puts("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);
+  	}
+  }
+  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);
+    }
+  }  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.
+`);
+}
+
+
+
+
+
+
+
+
+//functin cpp
+
+function cpp_code() {
+	return cpp_code = `
+#include <cstddef>
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <cstring>
+#include <map>
+
+enum {INT, DOUBLE, STRING, VECTOR, MAP} Objects;
+
+#define c construct
+
+class Object {
+public:
+	double type, *value, refs; operator const std::string() const;
+
+//operator const std::string() const;
+
+Object& print(void);
+
+
+bool operator < (Object a) const {
+	return (const std::string)(*this) < (const std::string)(a);
+};
+
+};
+
+template <class A>
+class Array_sub : public std::vector<A>
+{
+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 ( Object& i: *this) {
+				if (i.refs) {
+					--i.refs;
+				free(i.value);
+				}
+			}
+	}
+	
+
+
+	inline Array_sub<A>& operator<< (A v) {
+		push(v);
+		return *this;
+	}
+
+	inline auto surround(const char* first=nullptr, const char* second=nullptr) {
+
+		typedef Array_sub<A> Array;
+		Array b{};
+		for (size_t i = 0; i < this->size(); ++i) {
+			std::string s{first};
+			s+= (std::string)((*this)[i]);
+			s += second;
+			
+			b.push(c(strdup(s.c_str()), 1));
+		}
+		return b;
+	}
+
+	inline auto js() {
+		return surround("<script type='text/javascript'>", "</script>");
+	}
+
+	inline Object construct(const char* const a, const double refs=0)
+		{
+		return Object{2, (double*)a, refs};
+	}
+
+	//const double refs=0
+	
+	operator const std::string() const {
+		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() {
+		return surround("<html><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()   const {
+		std::ostringstream str;
+		str << "[";
+	for (size_t  i = 0; i < this->size(); ++i) {
+		str << (std::string)((*this)[i]);
+
+		if (i == this->size() - 1) {
+		} else {
+			str << ", ";
+		}
+	}
+		str << "]";
+
+
+
+return str.str();
+
+}
+};
+typedef Array_sub<Object> Array;
+
+
+
+
+Object::operator const std::string()   const  {
+	const Object& 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 double a = *(double*)&val_.value;
+		return std::to_string(a);
+	}
+
+	if (val_.type == VECTOR) {
+		return (*(Array       **)(&val_.value))->to_s();
+	}
+
+				std::string map_str = "{";
+//			std::map<A,
+
+			auto& map = (**(std::map<Object,Object>**)(&val_.value));
+//				std::cout << map["a"] << std::endl;
+//std::cout << map.size();
+//std::cout << map.length() << s
+			for (auto i : map) {
+				map_str += (std::string)(i.first);
+				map_str += ": ";
+				
+				map_str += (std::string)(i.second);
+
+				map_str += ", ";
+			}
+//			map_str[map_str.size() = 
+			if (map_str.size  ()          ) {
+				map_str[map_str.size() - 2] = '}';
+				map_str.resize(map_str.size() - 1);
+			}
+
+//			std::cout << map_str;
+
+			return map_str;
+
+
+	std::cout << "Error";
+	exit(1);
+};
+
+static inline void puts(std::string a) {
+	puts(a.c_str());
+}
+
+Object& Object::print() {
+	puts(((std::string)(*this)).c_str());
+	return *this;
+}
+Object construct(const long long int a) { return Object{0, (double*)a,0}; }
+Object construct(std::map<Object, Object> a, const double refs=0) {return Object{4,       (double*)&a,refs}; }
+
+Object construct(Array a) {return Object{3,       (double*)&a,0}; }
+Object operator ""_c(unsigned long long a) {
+	return c(a);
+}
+
+Object construct(const double a) {
+	return Object{1,        *(double**)&a, 0};
+
+}
+
+Object construct(const char* const a, const double refs=0) {
+	return Object{2, (double*)a,( refs)  };
+}
+
+
+
+`;
+}          function nums(a) {
+		if (typeof(a) != "number")
+
+		   					return mod(a);
+
+		   			//while (1) console.log(a)
+		if (a.toString().includes(".")) {
+
+			return "c(" + a + ")";
+		} else {
+			return "c(" + a + "ll)";  };       }
+
+
+//functin
+
+function cpp_pre_code() {
+	return cpp_code();
+}
+function set_kv(kv) {
+			for (var i_ of [0, 1])
+				kv[i_] = nums(kv[i_])
+				
+				//}
+
+			//}
+
+}
+
+function surround(a) { 
+	return "c(" + a + ")";
+}
+function mod(array, a=0) {
+	if (typeof(array) == "string") { return surround(JSON.stringify(array)); }
+	a = a + 1
+	if (a == 1) {
+	var str = "Array{"; } else
+	var str = "";
+	var element = false;
+
+
+	
+try {
+//	let str = "";
+	if(typeof(array)=='object'&&array.length===undefined) {
+		str = "c("+"\n" + "\t".repeat(a) + 
+		"std::map<Object, Object  >{";
+//		var element
+		var a = 0;
+		console.log(array)
+//		fs.writeFileSync("args/" + 
+		const s = JSON.stringify;
+		for (var i in array) {var kv=[i,array[i]];  element    = true
+		set_kv(kv);
+			const t = "  Object ";
+			const pair = "std::pair<" + t + "," + t + ">";
+			str += pair + "(" + kv.join(",") + ")";
+
+			str += ", ";
+}
+str = str.replace(/, $/, "}" + ")  ,   /* end of map */")//";
+
+	}
+	else
+	if (array.length === undefined) {
+		array = ["", array]
+		set_kv(array);   return array[1];
+	} else
+	for (var i of array ) {
+//		if (a == 
+if (typeof(i) != 'number') {
+		if (typeof(i) == 'object' && i.join === undefined) {
+			str += mod(i, a);
+		} else if(typeof(i) == "string") {
+			const SEPARATOR=",";
+				str += "c(" + JSON.stringify(i)+")  /* string literal */" + SEPARATOR
+			} else {
+		str += "\t".repeat(a) + "c(" + "Array"+"{"+"\n"+ "\t".repeat(a) + mod(i, a) + "\t".repeat(a-1) + "}" + ")" + ",\n"
+}
+}
+		else {
+
+			const value = ["", i];
+			set_kv(value);
+	str += value[1] + ", ";
+	
+}
+}
+
+if (a==1) str +="}";
+//str = str.slice(0, s
+
+return str.replace(/, $/, "");
+} catch (e) {
+	console.warn(e);
+	process.exit(1);
+}
+
+}

data/proj/a.c

@@ -0,0 +1 @@
+int main_() { foo(); }

data/proj/a.rs

@@ -0,0 +1,18 @@
+use std::os::raw::c_char;
+#[link(name = "b.o", kind = "static")]
+
+#[no_mangle]
+pub extern "C" fn foo(x:      *const c_char) {
+	println!("Hi");
+}
+//#[link(name = "/home/a/proj/lib.o")]
+extern {
+fn main_() -> i64;
+}
+//extern unsafe fn main_();
+fn main() {
+	unsafe {
+	main_();
+}
+}
+

data/proj/b.rs

@@ -0,0 +1,22 @@
+// This is a comment, and is ignored by the compiler
+// You can test this code by clicking the "Run" button over there ->
+// or if you prefer to use your keyboard, you can use the "Ctrl + Enter" shortcut
+
+// This code is editable, feel free to hack it!
+// You can always return to the original code by clicking the "Reset" button ->
+
+fn very_wordy() {
+	println!("Hi!");
+}
+
+// This is the main function
+fn main() {
+    // Statements here are executed when the compiled binary is called
+
+    // Print text to the console
+    let a = "";//"Hello World           ".trim().split(" ").collect::<Vec<_>>().join("FOO");
+    println!("{}", a);
+    very_wordy();
+
+//    system("ls");
+}

data/proj/linker.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+
+gcc -c a.c -o a.o;
+
+
+
+cc "$@" a.o

data/proj/save_last

@@ -0,0 +1,4 @@
+echo Copying and saving
+our=`history | tail -n 2 | head -n 1 | gsub '.+?\s+(.+)' '\1' | tee "$1"`
+echo "$our" | xclip -selection c
+echo \""$our"\" | green

data/push

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+rm -f *.gem                                                   nohup.out
+PATH=bin:$PATH
+
+
+echo -n 0.0. | blue
+cat VERSION_NUMBER | blue
+echo Incrementing | blue
+(cat VERSION_NUMBER; echo 1) | add | squeeze 0 0 VERSION_NUMBER;
+version=0.0.`cat VERSION_NUMBER`
+echo $version | red
+#echo version 
+#cat VERSION_NUMBER | red
+echo Success | green
+gem build ./*.gemspec --verbose      || exit 1
+gem push *.gem --verbose