mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
Merge branch 'master' of github.com:github/linguist into chapel-lang
Conflicts: lib/linguist/samples.json
This commit is contained in:
Thomas Van Doren
146
samples/Clojure/index.cljs.hl
Normal file
146
samples/Clojure/index.cljs.hl
Normal file
@@ -0,0 +1,146 @@
|
||||
;; Copyright (c) Alan Dipert and Micha Niskin. All rights reserved.
|
||||
;; The use and distribution terms for this software are covered by the
|
||||
;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
|
||||
;; which can be found in the file epl-v10.html at the root of this distribution.
|
||||
;; By using this software in any fashion, you are agreeing to be bound by
|
||||
;; the terms of this license.
|
||||
;; You must not remove this notice, or any other, from this software.
|
||||
|
||||
(page "index.html"
|
||||
(:refer-clojure :exclude [nth])
|
||||
(:require
|
||||
[tailrecursion.hoplon.reload :refer [reload-all]]
|
||||
[tailrecursion.hoplon.util :refer [nth name pluralize]]
|
||||
[tailrecursion.hoplon.storage-atom :refer [local-storage]]))
|
||||
|
||||
;; utility functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(declare route state editing)
|
||||
|
||||
(reload-all)
|
||||
|
||||
(def mapvi (comp vec map-indexed))
|
||||
|
||||
(defn dissocv [v i]
|
||||
(let [z (- (dec (count v)) i)]
|
||||
(cond (neg? z) v
|
||||
(zero? z) (pop v)
|
||||
(pos? z) (into (subvec v 0 i) (subvec v (inc i))))))
|
||||
|
||||
(defn decorate [todo route editing i]
|
||||
(let [{done? :completed text :text} todo]
|
||||
(-> todo (assoc :editing (= editing i)
|
||||
:visible (and (not (empty? text))
|
||||
(or (= "#/" route)
|
||||
(and (= "#/active" route) (not done?))
|
||||
(and (= "#/completed" route) done?)))))))
|
||||
|
||||
;; persisted state cell (AKA: stem cell) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(def state (-> (cell []) (local-storage ::store)))
|
||||
|
||||
;; local state cells ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defc loaded? false)
|
||||
(defc editing nil)
|
||||
(def route (route-cell "#/"))
|
||||
|
||||
;; formula cells (computed state) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defc= completed (filter :completed state))
|
||||
(defc= active (remove :completed state))
|
||||
(defc= plural-item (pluralize "item" (count active)))
|
||||
(defc= todos (mapvi #(list %1 (decorate %2 route editing %1)) state))
|
||||
|
||||
;; state transition functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defn todo [t] {:completed false :text t})
|
||||
(defn destroy! [i] (swap! state dissocv i))
|
||||
(defn done! [i v] (swap! state assoc-in [i :completed] v))
|
||||
(defn clear-done! [& _] (swap! state #(vec (remove :completed %))))
|
||||
(defn new! [t] (when (not (empty? t)) (swap! state conj (todo t))))
|
||||
(defn all-done! [v] (swap! state #(mapv (fn [x] (assoc x :completed v)) %)))
|
||||
(defn editing! [i v] (reset! editing (if v i nil)))
|
||||
(defn text! [i v] (if (empty? v) (destroy! i) (swap! state assoc-in [i :text] v)))
|
||||
|
||||
;; page ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(html :lang "en"
|
||||
(head
|
||||
(meta :charset "utf-8")
|
||||
(meta :http-equiv "X-UA-Compatible" :content "IE=edge,chrome=1")
|
||||
(link :rel "stylesheet" :href "base.css")
|
||||
(title "Hoplon • TodoMVC"))
|
||||
(body
|
||||
(noscript
|
||||
(div :id "noscript"
|
||||
(p "JavaScript is required to view this page.")))
|
||||
(div
|
||||
(section :id "todoapp"
|
||||
(header :id "header"
|
||||
(h1 "todos")
|
||||
(form :on-submit #(do (new! (val-id :new-todo))
|
||||
(do! (by-id :new-todo) :value ""))
|
||||
(input
|
||||
:id "new-todo"
|
||||
:type "text"
|
||||
:autofocus true
|
||||
:placeholder "What needs to be done?"
|
||||
:on-blur #(do! (by-id :new-todo) :value ""))))
|
||||
(section
|
||||
:id "main"
|
||||
:do-toggle (cell= (not (and (empty? active) (empty? completed))))
|
||||
(input
|
||||
:id "toggle-all"
|
||||
:type "checkbox"
|
||||
:do-attr (cell= {:checked (empty? active)})
|
||||
:on-click #(all-done! (val-id :toggle-all)))
|
||||
(label :for "toggle-all"
|
||||
"Mark all as complete")
|
||||
(ul :id "todo-list"
|
||||
(loop-tpl
|
||||
:reverse true
|
||||
:bind-ids [done# edit#]
|
||||
:bindings [[i {edit? :editing done? :completed todo-text :text show? :visible}] todos]
|
||||
(li
|
||||
:do-class (cell= {:completed done? :editing edit?})
|
||||
:do-toggle show?
|
||||
(div :class "view" :on-dblclick #(editing! @i true)
|
||||
(input
|
||||
:id done#
|
||||
:type "checkbox"
|
||||
:class "toggle"
|
||||
:do-attr (cell= {:checked done?})
|
||||
:on-click #(done! @i (val-id done#)))
|
||||
(label (text "~{todo-text}"))
|
||||
(button
|
||||
:type "submit"
|
||||
:class "destroy"
|
||||
:on-click #(destroy! @i)))
|
||||
(form :on-submit #(editing! @i false)
|
||||
(input
|
||||
:id edit#
|
||||
:type "text"
|
||||
:class "edit"
|
||||
:do-value todo-text
|
||||
:do-focus edit?
|
||||
:on-blur #(when @edit? (editing! @i false))
|
||||
:on-change #(when @edit? (text! @i (val-id edit#)))))))))
|
||||
(footer
|
||||
:id "footer"
|
||||
:do-toggle (cell= (not (and (empty? active) (empty? completed))))
|
||||
(span :id "todo-count"
|
||||
(strong (text "~(count active) "))
|
||||
(span (text "~{plural-item} left")))
|
||||
(ul :id "filters"
|
||||
(li (a :href "#/" :do-class (cell= {:selected (= "#/" route)}) "All"))
|
||||
(li (a :href "#/active" :do-class (cell= {:selected (= "#/active" route)}) "Active"))
|
||||
(li (a :href "#/completed" :do-class (cell= {:selected (= "#/completed" route)}) "Completed")))
|
||||
(button
|
||||
:type "submit"
|
||||
:id "clear-completed"
|
||||
:on-click #(clear-done!)
|
||||
(text "Clear completed (~(count completed))"))))
|
||||
(footer :id "info"
|
||||
(p "Double-click to edit a todo")
|
||||
(p "Part of " (a :href "http://github.com/tailrecursion/hoplon-demos/" "hoplon-demos"))))))
|
||||
580
samples/Cycript/utils.cy
Normal file
580
samples/Cycript/utils.cy
Normal file
@@ -0,0 +1,580 @@
|
||||
(function(utils) {
|
||||
// Load C functions declared in utils.loadFuncs
|
||||
var shouldLoadCFuncs = true;
|
||||
// Expose the C functions to cycript's global scope
|
||||
var shouldExposeCFuncs = true;
|
||||
// Expose C constants to cycript's global scope
|
||||
var shouldExposeConsts = true;
|
||||
// Expose functions defined here to cycript's global scope
|
||||
var shouldExposeFuncs = true;
|
||||
// Which functions to expose
|
||||
var funcsToExpose = ["exec", "include", "sizeof", "logify", "apply", "str2voidPtr", "voidPtr2str", "double2voidPtr", "voidPtr2double", "isMemoryReadable", "isObject", "makeStruct"];
|
||||
|
||||
// C functions that utils.loadFuncs loads
|
||||
var CFuncsDeclarations = [
|
||||
// <stdlib.h>
|
||||
"void *calloc(size_t num, size_t size)",
|
||||
// <string.h>
|
||||
"char *strcpy(char *restrict dst, const char *restrict src)",
|
||||
"char *strdup(const char *s1)",
|
||||
"void* memset(void* dest, int ch, size_t count)",
|
||||
// <stdio.h>
|
||||
"FILE *fopen(const char *, const char *)",
|
||||
"int fclose(FILE *)",
|
||||
"size_t fread(void *restrict, size_t, size_t, FILE *restrict)",
|
||||
"size_t fwrite(const void *restrict, size_t, size_t, FILE *restrict)",
|
||||
// <mach.h>
|
||||
"mach_port_t mach_task_self()",
|
||||
"kern_return_t task_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *tn)",
|
||||
"kern_return_t mach_vm_protect(vm_map_t target_task, mach_vm_address_t address, mach_vm_size_t size, boolean_t set_maximum, vm_prot_t new_protection)",
|
||||
"kern_return_t mach_vm_write(vm_map_t target_task, mach_vm_address_t address, vm_offset_t data, mach_msg_type_number_t dataCnt)",
|
||||
"kern_return_t mach_vm_read(vm_map_t target_task, mach_vm_address_t address, mach_vm_size_t size, vm_offset_t *data, mach_msg_type_number_t *dataCnt)",
|
||||
];
|
||||
|
||||
/*
|
||||
Replacement for eval that can handle @encode etc.
|
||||
|
||||
Usage:
|
||||
cy# utils.exec("@encode(void *(int, char))")
|
||||
@encode(void*(int,char))
|
||||
*/
|
||||
utils.exec = function(str) {
|
||||
var mkdir = @encode(int (const char *, int))(dlsym(RTLD_DEFAULT, "mkdir"));
|
||||
var tempnam = @encode(char *(const char *, const char *))(dlsym(RTLD_DEFAULT, "tempnam"));
|
||||
var fopen = @encode(void *(const char *, const char *))(dlsym(RTLD_DEFAULT, "fopen"));
|
||||
var fclose = @encode(int (void *))(dlsym(RTLD_DEFAULT, "fclose"));
|
||||
var fwrite = @encode(int (const char *, int, int, void *))(dlsym(RTLD_DEFAULT, "fwrite"));
|
||||
var symlink = @encode(int (const char *, const char *))(dlsym(RTLD_DEFAULT, "symlink"));
|
||||
var unlink = @encode(int (const char *))(dlsym(RTLD_DEFAULT, "unlink"));
|
||||
var getenv = @encode(const char *(const char *))(dlsym(RTLD_DEFAULT, "getenv"));
|
||||
var setenv = @encode(int (const char *, const char *, int))(dlsym(RTLD_DEFAULT, "setenv"));
|
||||
|
||||
var libdir = "/usr/lib/cycript0.9";
|
||||
var dir = libdir + "/tmp";
|
||||
|
||||
mkdir(dir, 0777);
|
||||
|
||||
// This is needed because tempnam seems to ignore the first argument on i386
|
||||
var old_tmpdir = getenv("TMPDIR");
|
||||
setenv("TMPDIR", dir, 1);
|
||||
|
||||
// No freeing :(
|
||||
var f = tempnam(dir, "exec-");
|
||||
setenv("TMPDIR", old_tmpdir, 1);
|
||||
if(!f) {
|
||||
return false;
|
||||
}
|
||||
|
||||
symlink(f, f + ".cy");
|
||||
|
||||
str = "exports.result = " + str;
|
||||
|
||||
var handle = fopen(f, "w");
|
||||
fwrite(str, str.length, 1, handle);
|
||||
fclose(handle);
|
||||
|
||||
var r;
|
||||
var except = null;
|
||||
try {
|
||||
r = require(f.replace(libdir + "/", ""));
|
||||
} catch(e) {
|
||||
except = e;
|
||||
}
|
||||
|
||||
unlink(f + ".cy");
|
||||
unlink(f);
|
||||
|
||||
if(except !== null) {
|
||||
throw except;
|
||||
}
|
||||
|
||||
return r.result;
|
||||
};
|
||||
|
||||
/*
|
||||
Applies known typedefs
|
||||
Used in utils.include and utils.makeStruct
|
||||
|
||||
Usage:
|
||||
cy# utils.applyTypedefs("mach_vm_address_t")
|
||||
"uint64_t"
|
||||
*/
|
||||
utils.applyTypedefs = function(str) {
|
||||
var typedefs = {
|
||||
"struct": "",
|
||||
"restrict": "",
|
||||
"FILE": "void",
|
||||
"size_t": "uint64_t",
|
||||
"uintptr_t": "unsigned long",
|
||||
"kern_return_t": "int",
|
||||
"mach_port_t": "unsigned int",
|
||||
"mach_port_name_t": "unsigned int",
|
||||
"vm_offset_t": "unsigned long",
|
||||
"vm_size_t": "unsigned long",
|
||||
"mach_vm_address_t": "uint64_t",
|
||||
"mach_vm_offset_t": "uint64_t",
|
||||
"mach_vm_size_t": "uint64_t",
|
||||
"vm_map_offset_t": "uint64_t",
|
||||
"vm_map_address_t": "uint64_t",
|
||||
"vm_map_size_t": "uint64_t",
|
||||
"mach_port_context_t": "uint64_t",
|
||||
"vm_map_t": "unsigned int",
|
||||
"boolean_t": "unsigned int",
|
||||
"vm_prot_t": "int",
|
||||
"mach_msg_type_number_t": "unsigned int",
|
||||
"cpu_type_t": "int",
|
||||
"cpu_subtype_t": "int",
|
||||
"cpu_threadtype_t": "int",
|
||||
};
|
||||
|
||||
for(var k in typedefs) {
|
||||
str = str.replace(new RegExp("(\\s|\\*|,|\\(|^)" + k + "(\\s|\\*|,|\\)|$)", "g"), "$1" + typedefs[k] + "$2");
|
||||
}
|
||||
|
||||
return str;
|
||||
};
|
||||
|
||||
/*
|
||||
Parses a C function declaration and returns the function name and cycript type
|
||||
If load is true, tries to load it into cycript using utils.exec
|
||||
|
||||
Usage:
|
||||
cy# var str = "void *calloc(size_t num, size_t size)";
|
||||
"void *calloc(size_t num, size_t size)"
|
||||
cy# utils.include(str)
|
||||
["calloc","@encode(void *(uint64_t num, uint64_t size))(140735674376857)"]
|
||||
cy# var ret = utils.include(str, true)
|
||||
["calloc",0x7fff93e0e299]
|
||||
cy# ret[1].type
|
||||
@encode(void*(unsigned long long int,unsigned long long int))
|
||||
cy# ret[1](100, 1)
|
||||
0x100444100
|
||||
*/
|
||||
utils.include = function(str, load) {
|
||||
var re = /^\s*([^(]*(?:\s+|\*))(\w*)\s*\(([^)]*)\)\s*;?\s*$/;
|
||||
var match = re.exec(str);
|
||||
if(!match) {
|
||||
return -1;
|
||||
}
|
||||
var rType = utils.applyTypedefs(match[1]);
|
||||
var name = match[2];
|
||||
var args = match[3];
|
||||
|
||||
var argsRe = /([^,]+)(?:,|$)/g;
|
||||
var argsTypes = [];
|
||||
while((match = argsRe.exec(args)) !== null) {
|
||||
var type = utils.applyTypedefs(match[1]);
|
||||
argsTypes.push(type);
|
||||
}
|
||||
|
||||
var encodeString = "@encode(";
|
||||
encodeString += rType + "(";
|
||||
encodeString += argsTypes.join(", ") + "))";
|
||||
|
||||
var fun = dlsym(RTLD_DEFAULT, name);
|
||||
if(fun !== null) {
|
||||
encodeString += "(" + fun + ")";
|
||||
if(load) {
|
||||
return [name, utils.exec(encodeString)];
|
||||
}
|
||||
} else if(load) {
|
||||
throw "Function couldn't be found with dlsym!";
|
||||
}
|
||||
|
||||
return [name, encodeString];
|
||||
};
|
||||
|
||||
/*
|
||||
Loads the function declaration in the defs array using utils.exec and exposes to cycript's global scope
|
||||
Is automatically called if shouldLoadCFuncs is true
|
||||
*/
|
||||
utils.funcs = {};
|
||||
utils.loadfuncs = function(expose) {
|
||||
for(var i = 0; i < CFuncsDeclarations.length; i++) {
|
||||
try {
|
||||
var o = utils.include(CFuncsDeclarations[i], true);
|
||||
utils.funcs[o[0]] = o[1];
|
||||
if(expose) {
|
||||
Cycript.all[o[0]] = o[1];
|
||||
}
|
||||
} catch(e) {
|
||||
system.print("Failed to load function: " + i);
|
||||
try {
|
||||
system.print(utils.include(CFuncsDeclarations[i]));
|
||||
} catch(e2) {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
Calculates the size of a type like the C operator sizeof
|
||||
|
||||
Usage:
|
||||
cy# utils.sizeof(int)
|
||||
4
|
||||
cy# utils.sizeof(@encode(void *))
|
||||
8
|
||||
cy# utils.sizeof("mach_vm_address_t")
|
||||
8
|
||||
*/
|
||||
utils.sizeof = function(type) {
|
||||
if(typeof type === "string") {
|
||||
type = utils.applyTypedefs(type);
|
||||
type = utils.exec("@encode(" + type + ")");
|
||||
}
|
||||
|
||||
// (const) char * has "infinite" preceision
|
||||
if(type.toString().slice(-1) === "*") {
|
||||
return utils.sizeof(@encode(void *));
|
||||
}
|
||||
|
||||
// float and double
|
||||
if(type.toString() === @encode(float).toString()) {
|
||||
return 4;
|
||||
} else if (type.toString() === @encode(double).toString()) {
|
||||
return 8;
|
||||
}
|
||||
|
||||
var typeInstance = type(0);
|
||||
|
||||
if(typeInstance instanceof Object) {
|
||||
// Arrays
|
||||
if("length" in typeInstance) {
|
||||
return typeInstance.length * utils.sizeof(typeInstance.type);
|
||||
}
|
||||
|
||||
// Structs
|
||||
if(typeInstance.toString() === "[object Struct]") {
|
||||
var typeStr = type.toString();
|
||||
var arrayTypeStr = "[2" + typeStr + "]";
|
||||
var arrayType = new Type(arrayTypeStr);
|
||||
|
||||
var arrayInstance = new arrayType;
|
||||
|
||||
return @encode(void *)(&(arrayInstance[1])) - @encode(void *)(&(arrayInstance[0]));
|
||||
}
|
||||
}
|
||||
|
||||
for(var i = 0; i < 5; i++) {
|
||||
var maxSigned = Math.pow(2, 8 * Math.pow(2, i) - 1) - 1;
|
||||
if(i === 3) {
|
||||
// Floating point fix ;^)
|
||||
maxSigned /= 1000;
|
||||
}
|
||||
|
||||
// can't use !== or sizeof(void *) === 0.5
|
||||
if(type(maxSigned) != maxSigned) {
|
||||
return Math.pow(2, i - 1);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
Logs a specific message sent to an instance of a class like logify.pl in theos
|
||||
Requires Cydia Substrate (com.saurik.substrate.MS) and NSLog (org.cycript.NSLog) modules
|
||||
Returns the old message returned by MS.hookMessage (Note: this is not just the old message!)
|
||||
|
||||
Usage:
|
||||
cy# var oldm = utils.logify(objc_getMetaClass(NSNumber), @selector(numberWithDouble:))
|
||||
...
|
||||
cy# var n = [NSNumber numberWithDouble:1.5]
|
||||
2014-07-28 02:26:39.805 cycript[71213:507] +[<NSNumber: 0x10032d0c4> numberWithDouble:1.5]
|
||||
2014-07-28 02:26:39.806 cycript[71213:507] = 1.5
|
||||
@1.5
|
||||
*/
|
||||
utils.logify = function(cls, sel) {
|
||||
@import com.saurik.substrate.MS;
|
||||
@import org.cycript.NSLog;
|
||||
|
||||
var oldm = {};
|
||||
|
||||
MS.hookMessage(cls, sel, function() {
|
||||
var args = [].slice.call(arguments);
|
||||
|
||||
var selFormat = sel.toString().replace(/:/g, ":%@ ").trim();
|
||||
var logFormat = "%@[<%@: 0x%@> " + selFormat + "]";
|
||||
|
||||
var standardArgs = [logFormat, class_isMetaClass(cls)? "+": "-", cls.toString(), (&this).valueOf().toString(16)];
|
||||
var logArgs = standardArgs.concat(args);
|
||||
|
||||
NSLog.apply(null, logArgs);
|
||||
|
||||
var r = oldm->apply(this, arguments);
|
||||
|
||||
if(r !== undefined) {
|
||||
NSLog(" = %@", r);
|
||||
}
|
||||
|
||||
return r;
|
||||
}, oldm);
|
||||
|
||||
return oldm;
|
||||
};
|
||||
|
||||
/*
|
||||
Calls a C function by providing its name and arguments
|
||||
Doesn't support structs
|
||||
Return value is always a void pointer
|
||||
|
||||
Usage:
|
||||
cy# utils.apply("printf", ["%s %.3s, %d -> %c, float: %f\n", "foo", "barrrr", 97, 97, 1.5])
|
||||
foo bar, 97 -> a, float: 1.500000
|
||||
0x22
|
||||
*/
|
||||
utils.apply = function(fun, args) {
|
||||
if(!(args instanceof Array)) {
|
||||
throw "Args needs to be an array!";
|
||||
}
|
||||
|
||||
var argc = args.length;
|
||||
var voidPtr = @encode(void *);
|
||||
var argTypes = [];
|
||||
for(var i = 0; i < argc; i++) {
|
||||
var argType = voidPtr;
|
||||
|
||||
var arg = args[i];
|
||||
if(typeof arg === "string") {
|
||||
argType = @encode(char *);
|
||||
}
|
||||
if(typeof arg === "number" && arg % 1 !== 0) {
|
||||
argType = @encode(double);
|
||||
}
|
||||
|
||||
argTypes.push(argType);
|
||||
}
|
||||
|
||||
var type = voidPtr.functionWith.apply(voidPtr, argTypes);
|
||||
|
||||
if(typeof fun === "string") {
|
||||
fun = dlsym(RTLD_DEFAULT, fun);
|
||||
}
|
||||
|
||||
if(!fun) {
|
||||
throw "Function not found!";
|
||||
}
|
||||
|
||||
return type(fun).apply(null, args);
|
||||
};
|
||||
|
||||
/*
|
||||
Converts a string (char *) to a void pointer (void *)
|
||||
You can't cast to strings to void pointers and vice versa in cycript. Blame saurik.
|
||||
|
||||
Usage:
|
||||
cy# var voidPtr = utils.str2voidPtr("foobar")
|
||||
0x100331590
|
||||
cy# utils.voidPtr2str(voidPtr)
|
||||
"foobar"
|
||||
*/
|
||||
utils.str2voidPtr = function(str) {
|
||||
var strdup = @encode(void *(char *))(dlsym(RTLD_DEFAULT, "strdup"));
|
||||
return strdup(str);
|
||||
};
|
||||
|
||||
/*
|
||||
The inverse function of str2voidPtr
|
||||
*/
|
||||
utils.voidPtr2str = function(voidPtr) {
|
||||
var strdup = @encode(char *(void *))(dlsym(RTLD_DEFAULT, "strdup"));
|
||||
return strdup(voidPtr);
|
||||
};
|
||||
|
||||
/*
|
||||
Converts a double into a void pointer
|
||||
This can be used to view the binary representation of a floating point number
|
||||
|
||||
Usage:
|
||||
cy# var n = utils.double2voidPtr(-1.5)
|
||||
0xbff8000000000000
|
||||
cy# utils.voidPtr2double(n)
|
||||
-1.5
|
||||
*/
|
||||
utils.double2voidPtr = function(n) {
|
||||
var doublePtr = new double;
|
||||
*doublePtr = n;
|
||||
|
||||
var voidPtrPtr = @encode(void **)(doublePtr);
|
||||
|
||||
return *voidPtrPtr;
|
||||
};
|
||||
|
||||
/*
|
||||
The inverse function of double2voidPtr
|
||||
*/
|
||||
utils.voidPtr2double = function(voidPtr) {
|
||||
var voidPtrPtr = new @encode(void **);
|
||||
*voidPtrPtr = voidPtr;
|
||||
|
||||
var doublePtr = @encode(double *)(voidPtrPtr);
|
||||
|
||||
return *doublePtr;
|
||||
};
|
||||
|
||||
/*
|
||||
Determines in a safe way if a memory location is readable
|
||||
|
||||
Usage:
|
||||
cy# utils.isMemoryReadable(0)
|
||||
false
|
||||
cy# utils.isMemoryReadable(0x1337)
|
||||
false
|
||||
cy# utils.isMemoryReadable(NSObject)
|
||||
true
|
||||
cy# var a = malloc(100); utils.isMemoryReadable(a)
|
||||
true
|
||||
*/
|
||||
utils.isMemoryReadable = function(ptr) {
|
||||
if(typeof ptr === "string") {
|
||||
return true;
|
||||
}
|
||||
|
||||
var fds = new @encode(int [2]);
|
||||
utils.apply("pipe", [fds]);
|
||||
var result = utils.apply("write", [fds[1], ptr, 1]) == 1;
|
||||
|
||||
utils.apply("close", [fds[0]]);
|
||||
utils.apply("close", [fds[1]]);
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
/*
|
||||
Determines in a safe way if the memory location contains an Objective-C object
|
||||
|
||||
Usage:
|
||||
cy# utils.isObject(0)
|
||||
false
|
||||
cy# utils.isObject(0x1337)
|
||||
false
|
||||
cy# utils.isObject(NSObject)
|
||||
true
|
||||
cy# utils.isObject(objc_getMetaClass(NSObject))
|
||||
true
|
||||
cy# utils.isObject([new NSObject init])
|
||||
true
|
||||
cy# var a = malloc(100); utils.isObject(a)
|
||||
false
|
||||
cy# *@encode(void **)(a) = NSObject; utils.isObject(a)
|
||||
true
|
||||
*/
|
||||
utils.isObject = function(obj) {
|
||||
obj = @encode(void *)(obj);
|
||||
var lastObj = -1;
|
||||
|
||||
function objc_isa_ptr(obj) {
|
||||
// See http://www.sealiesoftware.com/blog/archive/2013/09/24/objc_explain_Non-pointer_isa.html
|
||||
var objc_debug_isa_class_mask = 0x00000001fffffffa;
|
||||
obj = (obj & 1)? (obj & objc_debug_isa_class_mask): obj;
|
||||
|
||||
if((obj & (utils.sizeof(@encode(void *)) - 1)) != 0) {
|
||||
return null;
|
||||
} else {
|
||||
return obj;
|
||||
}
|
||||
}
|
||||
|
||||
function ptrValue(obj) {
|
||||
return obj? obj.valueOf(): null;
|
||||
}
|
||||
|
||||
var foundMetaClass = false;
|
||||
|
||||
for(obj = objc_isa_ptr(obj); utils.isMemoryReadable(obj); ) {
|
||||
obj = *@encode(void **)(obj);
|
||||
|
||||
if(ptrValue(obj) == ptrValue(lastObj)) {
|
||||
foundMetaClass = true;
|
||||
break;
|
||||
}
|
||||
|
||||
lastObj = obj;
|
||||
}
|
||||
|
||||
if(!foundMetaClass) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if(lastObj === -1 || lastObj === null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var obj_class = objc_isa_ptr(@encode(void **)(obj)[1]);
|
||||
|
||||
if(!utils.isMemoryReadable(obj_class)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var metaclass = objc_isa_ptr(@encode(void **)(obj_class)[0]);
|
||||
var superclass = objc_isa_ptr(@encode(void **)(obj_class)[1]);
|
||||
|
||||
return ptrValue(obj) == ptrValue(metaclass) && superclass == null;
|
||||
};
|
||||
|
||||
/*
|
||||
Creates a cycript struct type from a C struct definition
|
||||
|
||||
Usage:
|
||||
cy# var foo = makeStruct("int a; short b; char c; uint64_t d; double e;", "foo");
|
||||
@encode(foo)
|
||||
cy# var f = new foo
|
||||
&{a:0,b:0,c:0,d:0,e:0}
|
||||
cy# f->a = 100; f
|
||||
&{a:100,b:0,c:0,d:0,e:0}
|
||||
cy# *@encode(int *)(f)
|
||||
100
|
||||
*/
|
||||
utils.makeStruct = function(str, name) {
|
||||
var fieldRe = /(?:\s|\n)*([^;]+\s*(?:\s|\*))([^;]+)\s*;/g;
|
||||
|
||||
if(!name) {
|
||||
name = "struct" + Math.floor(Math.random() * 100000);
|
||||
}
|
||||
var typeStr = "{" + name + "=";
|
||||
|
||||
while((match = fieldRe.exec(str)) !== null) {
|
||||
var fieldType = utils.applyTypedefs(match[1]);
|
||||
var fieldName = match[2];
|
||||
var encodedType = utils.exec("@encode(" + fieldType + ")").toString();
|
||||
|
||||
typeStr += '"' + fieldName + '"' + encodedType;
|
||||
}
|
||||
|
||||
typeStr += "}";
|
||||
|
||||
return new Type(typeStr);
|
||||
};
|
||||
|
||||
// Various constants
|
||||
utils.constants = {
|
||||
VM_PROT_NONE: 0x0,
|
||||
VM_PROT_READ: 0x1,
|
||||
VM_PROT_WRITE: 0x2,
|
||||
VM_PROT_EXECUTE: 0x4,
|
||||
VM_PROT_NO_CHANGE: 0x8,
|
||||
VM_PROT_COPY: 0x10,
|
||||
VM_PROT_WANTS_COPY: 0x10,
|
||||
VM_PROT_IS_MASK: 0x40,
|
||||
};
|
||||
var c = utils.constants;
|
||||
c.VM_PROT_DEFAULT = c.VM_PROT_READ | c.VM_PROT_WRITE;
|
||||
c.VM_PROT_ALL = c.VM_PROT_READ | c.VM_PROT_WRITE | c.VM_PROT_EXECUTE;
|
||||
|
||||
if(shouldExposeConsts) {
|
||||
for(var k in c) {
|
||||
Cycript.all[k] = c[k];
|
||||
}
|
||||
}
|
||||
|
||||
if(shouldExposeFuncs) {
|
||||
for(var i = 0; i < funcsToExpose.length; i++) {
|
||||
var name = funcsToExpose[i];
|
||||
Cycript.all[name] = utils[name];
|
||||
}
|
||||
}
|
||||
|
||||
if(shouldLoadCFuncs) {
|
||||
utils.loadfuncs(shouldExposeCFuncs);
|
||||
}
|
||||
})(exports);
|
||||
31
samples/HTML+ERB/fishbowl.html.erb.deface
Normal file
31
samples/HTML+ERB/fishbowl.html.erb.deface
Normal file
@@ -0,0 +1,31 @@
|
||||
<!-- insert_before '[data-hook="buttons"]' -->
|
||||
<% if Spree::Config[:enable_fishbowl] %>
|
||||
<div class="row">
|
||||
<div class="twelve columns" id="fishbowl_preferences">
|
||||
<fieldset class="no-border-bottom">
|
||||
<legend align="center"><%= t(:fishbowl_settings)%></legend>
|
||||
<% @fishbowl_options.each do |key| %>
|
||||
<div class="field">
|
||||
<%= label_tag(key, t(key.to_s.gsub('fishbowl_', '').to_sym) + ': ') + tag(:br) %>
|
||||
<%= text_field_tag('preferences[' + key.to_s + ']', Spree::Config[key], { :size => 10, :class => 'fullwidth' }) %>
|
||||
</div>
|
||||
<% end %>
|
||||
<div class="field">
|
||||
<%= hidden_field_tag 'preferences[fishbowl_always_fetch_current_inventory]', '0' %>
|
||||
<%= check_box_tag('preferences[fishbowl_always_fetch_current_inventory]', "1", Spree::Config[:fishbowl_always_fetch_current_inventory]) %>
|
||||
<%= t(:always_fetch_current_inventory) %>
|
||||
</div>
|
||||
<% if !@location_groups.empty? %>
|
||||
<div class="field">
|
||||
<%= label_tag(:fishbowl_location_group, t(:location_group) + ': ') + tag(:br) %>
|
||||
<%= select('preferences', 'fishbowl_location_group', @location_groups, { :selected => Spree::Config[:fishbowl_location_group]}, { :class => ['select2', 'fullwidth'] }) %>
|
||||
</div>
|
||||
<% end %>
|
||||
</fieldset>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script type="text/javascript">
|
||||
$('.select2').select2();
|
||||
</script>
|
||||
<% end %>
|
||||
39
samples/HTML+ERB/index.html.erb
Normal file
39
samples/HTML+ERB/index.html.erb
Normal file
@@ -0,0 +1,39 @@
|
||||
<% provide(:title, @header) %>
|
||||
<% present @users do |user_presenter| %>
|
||||
<div class="row key-header">
|
||||
<h1><%= @header %></h1>
|
||||
</div>
|
||||
|
||||
<div class='row'>
|
||||
<div class='small-12 columns'>
|
||||
<%= will_paginate %>
|
||||
</div>
|
||||
</div>
|
||||
<div class="row key-table">
|
||||
<div class="small-12 columns">
|
||||
<div class="row key-table-row">
|
||||
<div class="small-2 columns">Name</div>
|
||||
<div class="small-3 columns">Email</div>
|
||||
<div class="small-1 columns">Chords</div>
|
||||
<div class="small-1 columns">Keys</div>
|
||||
<div class="small-1 columns">Tunings</div>
|
||||
<div class="small-1 columns">Credits</div>
|
||||
<div class="small-1 columns">Prem?</div>
|
||||
<div class="small-2 columns">Since?</div>
|
||||
</div>
|
||||
|
||||
<% if @users == [] %>
|
||||
<div class="row key-table-row">
|
||||
<div class="small-4 small-centered columns">No Users</div>
|
||||
</div>
|
||||
<% else %>
|
||||
<%= render @users %>
|
||||
<% end %>
|
||||
</div>
|
||||
</div>
|
||||
<div class='row'>
|
||||
<div class='small-12 columns'>
|
||||
<%= will_paginate %>
|
||||
</div>
|
||||
</div>
|
||||
<% end %>
|
||||
29
samples/Haml/buttons.html.haml.deface
Normal file
29
samples/Haml/buttons.html.haml.deface
Normal file
@@ -0,0 +1,29 @@
|
||||
/
|
||||
replace '.actions'
|
||||
|
||||
.pull-right
|
||||
.btn-group
|
||||
= link_to page.url, target: "_blank", title: t('.view_live_html'), class: "tip btn btn-xs btn-default" do
|
||||
%i.icon-picture.row-black
|
||||
|
||||
= link_to refinery.edit_admin_page_path(page.nested_url,
|
||||
switch_locale: (page.translations.first.locale unless page.translated_to_default_locale?)),
|
||||
title: t('edit', :scope => 'refinery.admin.pages'),
|
||||
class: "tip btn btn-xs btn-default" do
|
||||
%i.icon-edit.row-blue
|
||||
|
||||
|
||||
- if page.deletable?
|
||||
= link_to refinery.admin_page_path(page.nested_url),
|
||||
methode: :delete,
|
||||
title: t('delete', :scope => 'refinery.admin.pages'),
|
||||
class: "tip cancel confirm-delete btn btn-xs btn-default",
|
||||
data: { confirm: t('message', scope: 'refinery.admin.delete', title: page_title_with_translations(page)) } do
|
||||
%i.icon-trash.row-red
|
||||
- else
|
||||
%button.btn.btn-xs.btn-default.disabled
|
||||
%i.icon-trash
|
||||
|
||||
.btn-group
|
||||
= link_to refinery.new_admin_page_path(:parent_id => page.id), title: t('new', :scope => 'refinery.admin.pages'), class: "tip btn btn-xs btn-default" do
|
||||
%i.icon-plus.row-green
|
||||
Reference in New Issue
Block a user