├── .babelrc
├── .gitignore
├── LICENSE.md
├── README.md
├── driver.js
├── ob.js
├── package.json
├── src
    ├── acorn-jx.js
    ├── fs.js
    ├── index.js
    ├── recast-acorn-parser.js
    ├── recast-jx.js
    └── types-jx.js
├── test
    ├── app.objs
    ├── test.js
    └── tests.objs
└── webpack.config.js


/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"sourceType": "script",
 3 | 	"presets": [
 4 |     	[
 5 |     		"@babel/preset-env", 
 6 |     		{ 
 7 |       			"targets": "iOS 9"
 8 |     		}
 9 |     	],
10 |   	],
11 | }
12 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | 
 3 | # Logs
 4 | logs
 5 | *.log
 6 | npm-debug.log*
 7 | yarn-debug.log*
 8 | yarn-error.log*
 9 | 
10 | # Runtime data
11 | pids
12 | *.pid
13 | *.seed
14 | *.pid.lock
15 | 
16 | # Directory for instrumented libs generated by jscoverage/JSCover
17 | lib-cov
18 | 
19 | # Coverage directory used by tools like istanbul
20 | coverage
21 | 
22 | # nyc test coverage
23 | .nyc_output
24 | 
25 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
26 | .grunt
27 | 
28 | # Bower dependency directory (https://bower.io/)
29 | bower_components
30 | 
31 | # node-waf configuration
32 | .lock-wscript
33 | 
34 | # Compiled binary addons (https://nodejs.org/api/addons.html)
35 | build/Release
36 | 
37 | # Dependency directories
38 | node_modules/
39 | jspm_packages/
40 | 
41 | # Typescript v1 declaration files
42 | typings/
43 | 
44 | # Optional npm cache directory
45 | .npm
46 | 
47 | # Optional eslint cache
48 | .eslintcache
49 | 
50 | # Optional REPL history
51 | .node_repl_history
52 | 
53 | # Output of 'npm pack'
54 | *.tgz
55 | 
56 | # Yarn Integrity file
57 | .yarn-integrity
58 | 
59 | # dotenv environment variables file
60 | .env
61 | 
62 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright 2019 Kabir Oberai
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # objs-transpiler
 2 | 
 3 | The syntax transpiler for the [ObjectiveScript](https://objs.dev) programming language.
 4 | 
 5 | ## Usage
 6 | 
 7 | ### Setup
 8 | 
 9 | Include `ob.js` in your environment. This might, for example, entail using `<script src>`, `require()`, or `-[JSContext evaluateScript:]`.
10 | 
11 | ### API
12 | 
13 | ```ts
14 | OBJSTranspiler.transpile(source: string, minify: boolean = false): { code: string; map: string; }
15 | ```
16 | 
17 | **Parameters**:
18 | 
19 | - `source`: The input source code written in ObjectiveScript
20 | - `minify`: A flag which determines whether to minify the output
21 | 
22 | **Returns**:
23 | 
24 | - `code`: The generated JavaScript code, compatible with the ObjectiveScript runtime
25 | - `map`: A [source map](https://github.com/mozilla/source-map) representing the entire transformation
26 | 
27 | ```ts
28 | OBJSTranspiler.tokenize(source: string): Iterable<acorn.Token>
29 | ```
30 | 
31 | **Parameters**:
32 | 
33 | - `source`: The input source code written in ObjectiveScript
34 | 
35 | **Returns**: An `Iterable` of tokens
36 | 
37 | ## Development
38 | 
39 | Start by running `npm install` to set up the dependencies.
40 | 
41 | ### Iteration
42 | 
43 | Run `npm run driver` to see the output of transpiling `test/app.objs` without having to compile the full `ob.js` file.
44 | 
45 | **Note**: At present, the `minify` parameter cannot be used during iteration because that involves building `uglify.js` which is an artifact created while performing a full build.
46 | 
47 | ### Full Build
48 | 
49 | Use `npm run build` to perform a full build. The output will be the `ob.js` file at the root level of the repository.
50 | 
51 | ### Tests
52 | 
53 | Execute `npm test` to run the test suite. 
54 | 
55 | **Note**: Test coverage is currently low, so the results are not a very strong indicator of regressions.
56 | 
57 | ### Cleaning
58 | 
59 | Execute `npm run clean`.
60 | 


--------------------------------------------------------------------------------
/driver.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs');
2 | const objs = require("./src/index.js");
3 | fs.readFile('test/app.objs', function (err, file) {
4 | 	console.log(objs.transpile(file).code);
5 | });
6 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "objs-transpiler",
 3 |   "version": "1.0.0",
 4 |   "description": "objs to js transpiler",
 5 |   "repository": "kabiroberai/objs-transpiler",
 6 |   "license": "MIT",
 7 |   "main": "index.js",
 8 |   "author": "Kabir Oberai",
 9 |   "devDependencies": {
10 |     "@babel/cli": "^7.2.3",
11 |     "@babel/core": "^7.2.2",
12 |     "@babel/preset-env": "^7.2.3",
13 |     "mocha": "^5.2.0",
14 |     "uglify-es": "^3.3.9",
15 |     "webpack": "^4.28.3",
16 |     "webpack-cli": "^3.2.0"
17 |   },
18 |   "scripts": {
19 |     "build": "uglifyjs --self -cmo uglify.js && webpack && rm uglify.js && babel ob.js --out-file ob.js && uglifyjs ob.js -o ob.js # package standalone uglify, build everything, delete uglify, babelify package, uglify package",
20 |     "clean": "rm -f ob.js uglify.js",
21 |     "build:": "npm run build",
22 |     "build:clean": "npm run clean",
23 |     "driver": "node driver.js",
24 |     "test": "mocha"
25 |   },
26 |   "dependencies": {
27 |     "@babel/core": "^7.2.2",
28 |     "@babel/preset-env": "^7.2.3",
29 |     "acorn": "^6.0.5",
30 |     "recast": "^0.16.1",
31 |     "source-map": "^0.7.3"
32 |   },
33 |   "browserslist": [
34 |     "iOS 9"
35 |   ]
36 | }
37 | 


--------------------------------------------------------------------------------
/src/acorn-jx.js:
--------------------------------------------------------------------------------
  1 | // produces AST for OBJS
  2 | 
  3 | module.exports = function() {
  4 | 	return function(Parser) {
  5 | 		return plugin(Parser);
  6 | 	};
  7 | };
  8 | 
  9 | const SCOPE_FUNCTION = 2;
 10 | 
 11 | const acorn = require("acorn");
 12 | 
 13 | const jxKeywords = {};
 14 | function kw(tokenName, keyword, options = {}) {
 15 | 	options.keyword = keyword;
 16 | 	return jxKeywords[keyword] = new TokenType(tokenName, options);
 17 | }
 18 | 
 19 | const tt = acorn.tokTypes;
 20 | const TokenType = acorn.TokenType;
 21 | const tok = {
 22 | 	at: new TokenType("jxAt", { startsExpr: true }),
 23 | 	origCall: new TokenType("jxOrigCall", { startsExpr: true }),
 24 | 	startClass: new TokenType("jxStartClass"),
 25 | 	endClass: new TokenType("jxEndClass"),
 26 | 	startProtoList: new TokenType("jxStartProtoList"),
 27 | 	endProtoList: new TokenType("jxEndProtoList"),
 28 | 	startHook: new TokenType("jxStartHook"),
 29 | 	endHook: new TokenType("jxEndHook"),
 30 | 	blockStart: new TokenType("jxBlockStart", { startsExpr: true }),
 31 | 	func: new TokenType("jxFuncDef"),
 32 | 	variadicType: new TokenType("jxVariadicType"),
 33 | 	structType: new TokenType("jxStructType"),
 34 | 	structDef: new TokenType("jxStructDef"),
 35 | 	deref: new TokenType("jxDeref", { prefix: true, beforeExpr: true, startsExpr: true }),
 36 | 	ref: new TokenType("jxRef", { prefix: true, startsExpr: true }),
 37 | 	sizeof: new TokenType("jxSizeof", { startsExpr: true }),
 38 | 	encode: new TokenType("jxEncode", { startsExpr: true }),
 39 | 	cast: new TokenType("jxCast"),
 40 | 	extern: new TokenType("jxExtern"),
 41 | 	yes: kw("jxYes", "YES", { startsExpr: true }),
 42 | 	no: kw("jxNo", "NO", { startsExpr: true })
 43 | };
 44 | 
 45 | const TokContext = acorn.TokContext;
 46 | const ctx = {
 47 | 	cls: new TokContext("@class ...", true)
 48 | };
 49 | 
 50 | tok.startClass.updateContext = function() {
 51 | 	this.context.push(ctx.cls);
 52 | }
 53 | tok.endClass.updateContext = function() {
 54 | 	this.context.pop();
 55 | }
 56 | 
 57 | function plugin(Parser) {
 58 | 	return class extends Parser {
 59 | 		jx_eatTokenWord(word, offset) {
 60 | 			if (!offset) {
 61 | 				offset = 0;
 62 | 			}
 63 | 
 64 | 			if (this.input.slice(this.pos + offset, this.pos + offset + word.length) === word) {
 65 | 				this.pos += word.length + offset;
 66 | 				return true;
 67 | 			}
 68 | 			return false;
 69 | 		}
 70 | 
 71 | 		parseMaybeUnary(refDestructuringErrors, sawUnary) {
 72 | 			let isRef = this.type === tok.ref;
 73 | 			let isDeref = this.type === tok.deref;
 74 | 
 75 | 			if (isRef || isDeref) {
 76 | 				const node = this.startNode();
 77 | 			    node.operator = this.value;
 78 | 			    node.prefix = true;
 79 | 			    this.next();
 80 | 
 81 | 			    if (isRef) {
 82 | 			    	node.value = this.parseIdent(false).name;
 83 | 			    } else {
 84 | 			    	node.argument = this.parseMaybeUnary(null, true);
 85 | 			    }
 86 | 
 87 | 			    this.checkExpressionErrors(refDestructuringErrors, true);
 88 | 			    return this.finishNode(node, isRef ? "JXRef" : "JXDeref");
 89 | 			}
 90 | 
 91 | 			return super.parseMaybeUnary(refDestructuringErrors, sawUnary);
 92 | 		}
 93 | 
 94 | 		toAssignable(node, isBinding, refDestructuringErrors) {
 95 | 			if (node.type !== "JXDeref") {
 96 | 				return super.toAssignable(node, isBinding, refDestructuringErrors);
 97 | 			}
 98 | 
 99 | 			return node;
100 | 		}
101 | 
102 | 		checkLVal(expr, bindingType, checkClashes) {
103 | 			return expr.type === "JXDeref" 
104 | 				|| super.checkLVal(expr, bindingType, checkClashes);
105 | 		}
106 | 
107 | 		readToken(code) {
108 | 			const context = this.curContext();
109 | 
110 | 			if (context === ctx.cls && code === 60) { // <
111 | 				++this.pos;
112 | 				return this.finishToken(tok.startProtoList);
113 | 			}
114 | 
115 | 			if (context === ctx.cls && code === 62) { // >
116 | 				++this.pos;
117 | 				return this.finishToken(tok.endProtoList);
118 | 			}
119 | 
120 | 			// we check code first because comparing the entire string is a slow operation
121 | 			if (code === 64) { // @
122 | 				if (this.jx_eatTokenWord("@class")) {
123 | 					return this.finishToken(tok.startClass);
124 | 				}
125 | 
126 | 				if (this.jx_eatTokenWord("@end")) {
127 | 					return this.finishToken(tok.endClass);
128 | 				}
129 | 
130 | 				if (this.jx_eatTokenWord("@function")) {
131 | 					return this.finishToken(tok.func);
132 | 				}
133 | 
134 | 				if (this.jx_eatTokenWord("@struct")) {
135 | 					return this.finishToken(tok.structDef);
136 | 				}
137 | 
138 | 				if (this.jx_eatTokenWord("@sizeof")) {
139 | 					return this.finishToken(tok.sizeof);
140 | 				}
141 | 
142 | 				if (this.jx_eatTokenWord("@encode")) {
143 | 					return this.finishToken(tok.encode);
144 | 				}
145 | 
146 | 				if (this.jx_eatTokenWord("@cast")) {
147 | 					return this.finishToken(tok.cast);
148 | 				}
149 | 
150 | 				if (this.jx_eatTokenWord("@extern")) {
151 | 					return this.finishToken(tok.extern);
152 | 				}
153 | 
154 | 				++this.pos;
155 | 				return this.finishToken(tok.at);
156 | 			}
157 | 
158 | 			if (code === 37) { // %
159 | 				if (this.jx_eatTokenWord("%hook")) {
160 | 					return this.finishToken(tok.startHook);
161 | 				}
162 | 
163 | 				if (this.jx_eatTokenWord("%end")) {
164 | 					return this.finishToken(tok.endHook);
165 | 				}
166 | 
167 | 				if (this.jx_eatTokenWord("%orig")) {
168 | 					return this.finishToken(tok.origCall);
169 | 				}
170 | 			}
171 | 
172 | 			if (this.exprAllowed && code === 94) { // ^
173 | 				++this.pos;
174 | 				return this.finishToken(tok.blockStart);
175 | 			}
176 | 
177 | 			if (code === 46 && this.jx_eatTokenWord("...")) { // .
178 | 				return this.finishToken(tok.variadicType, "...");
179 | 			}
180 | 
181 | 			if (this.jx_eatTokenWord("struct")) {
182 | 				return this.finishToken(tok.structType);
183 | 			}
184 | 
185 | 			const keywords = Object.keys(jxKeywords);
186 | 			for (let i = 0; i < keywords.length; i++) {
187 | 				let keyword = keywords[i];
188 | 				if (this.jx_eatTokenWord(keyword)) {
189 | 					return this.finishToken(jxKeywords[keyword]);
190 | 				}
191 | 			}
192 | 
193 | 			if (this.exprAllowed && code === 38) { // &
194 | 				++this.pos;
195 | 				return this.finishToken(tok.ref, "&");
196 | 			}
197 | 
198 | 			if (this.exprAllowed && code === 42) { // *
199 | 				++this.pos;
200 | 				return this.finishToken(tok.deref, "*");
201 | 			}
202 | 
203 | 			return super.readToken(code);
204 | 		}
205 | 
206 | 		parseExprAtom(refDestructuringErrors) {
207 | 			const startPos = this.start, startLoc = this.startLoc;
208 | 
209 | 			if (this.eat(tok.at)) {
210 | 				if (this.type === tt.parenL) {
211 | 					return this.jx_parseBox(startPos, startLoc);
212 | 				} else {
213 | 					return this.jx_parseLiteral(startPos, startLoc, refDestructuringErrors);
214 | 				}
215 | 			}
216 | 
217 | 			switch (this.type) {
218 | 			case tt.bracketL:
219 | 				return this.jx_parseMaybeMethodCall(refDestructuringErrors);
220 | 			case tok.origCall:
221 | 				return this.jx_parseOrigCall();
222 | 			case tok.blockStart:
223 | 				return this.jx_parseBlock();
224 | 			case tok.sizeof:
225 | 				return this.jx_parseSizeof();
226 | 			case tok.encode:
227 | 				return this.jx_parseEncode();
228 | 			case tok.cast:
229 | 				return this.jx_parseCast();
230 | 			case tok.yes:
231 | 				return this.jx_parseBooleanLiteral(true);
232 | 			case tok.no:
233 | 				return this.jx_parseBooleanLiteral(false);
234 | 			}
235 | 
236 | 			return super.parseExprAtom(refDestructuringErrors);
237 | 		}
238 | 
239 | 		parseStatement(context, topLevel, exports) {
240 | 			if (this.type === tok.startClass) {
241 | 				return this.jx_parseClass();
242 | 			}
243 | 
244 | 			if (this.type === tok.startHook) {
245 | 				return this.jx_parseHook();
246 | 			}
247 | 
248 | 			if (this.type === tok.func) {
249 | 				return this.jx_parseFuncDef();
250 | 			}
251 | 
252 | 			if (this.type === tok.extern) {
253 | 				return this.jx_parseExternDef();
254 | 			}
255 | 
256 | 			if (this.type === tok.structDef) {
257 | 				return this.jx_parseStructDef();
258 | 			}
259 | 
260 | 			return super.parseStatement(context, topLevel, exports);
261 | 		}
262 | 
263 | 		jx_parseBooleanLiteral(value) {
264 | 			const node = this.startNode();
265 | 			node.value = value;
266 | 			this.next();
267 | 			return this.finishNode(node, "JXBoolean");
268 | 		}
269 | 
270 | 		jx_parseBasicType(typeArr) {
271 | 			let type = typeArr.join(" ");
272 | 
273 | 			const types = {
274 | 				"char": "c",
275 | 				"int": "i",
276 | 				"short": "s",
277 | 				// `long` is normally treated as `long long` for some reason, so use `q` instead of `l`
278 | 				"long": "q",
279 | 				"long long": "q",
280 | 				"unsigned char": "C",
281 | 				"unsigned int": "I",
282 | 				"unsigned short": "S",
283 | 				"unsigned long": "Q",
284 | 				"unsigned long long": "Q",
285 | 				"float": "f",
286 | 				"double": "d",
287 | 				"BOOL": "B",
288 | 				"void": "v",
289 | 				"char *": "*",
290 | 				"id": "@",
291 | 				"Class": "#",
292 | 				"SEL": ":",
293 | 				"...": "..." // for varargs
294 | 			};
295 | 
296 | 			let enc = types[type];
297 | 			if (enc === undefined) {
298 | 				this.raise(this.pos, `Unknown primitive type '${type}'`);
299 | 			}
300 | 
301 | 			return enc;
302 | 		}
303 | 
304 | 		jx_parseTypeArr(typeArr) {
305 | 			let lastPart = typeArr[typeArr.length - 1];
306 | 			let secondLastPart;
307 | 			if (typeArr.length > 1) {
308 | 				secondLastPart = typeArr[typeArr.length - 2];
309 | 			}
310 | 
311 | 			if (secondLastPart === "char" && lastPart === "*") {
312 | 				// string
313 | 				return this.jx_parseBasicType(typeArr);
314 | 			} else if (lastPart[lastPart.length - 1] === "*") {
315 | 				// other type of pointer
316 | 				if (lastPart.length === 1) {
317 | 					// if it's a single * then remove it and parse the rest
318 | 					typeArr.pop();
319 | 				} else {
320 | 					// if it's more than a single star then remove the last star and parse the rest
321 | 					typeArr[typeArr.length - 1] = lastPart.substring(0, lastPart.length - 1);
322 | 				}
323 | 				return `^${this.jx_parseTypeArr(typeArr)}`;
324 | 			} else if (typeof lastPart === "number") {
325 | 				const len = typeArr.pop();
326 | 				return `[${len}${this.jx_parseTypeArr(typeArr)}]`;
327 | 			} else if (lastPart.substring(0, 7) === "struct ") {
328 | 				const structName = typeArr.pop().substring(7);
329 | 				if (!this.structNodes || !(this.structNodes[structName])) {
330 | 					this.raise(this.pos, `Unknown struct type '${structName}'`);
331 | 				}
332 | 				return this.structNodes[structName].encoding;
333 | 			} else {
334 | 				return this.jx_parseBasicType(typeArr);
335 | 			}
336 | 		}
337 | 
338 | 		jx_parseType(hasName, allowVoid, allowVariadic) {
339 | 			// TODO: Add function and block support
340 | 
341 | 			const node = this.startNode();
342 | 
343 | 			let typeArr = [];
344 | 			for (;;) {
345 | 				if (this.value) {
346 | 					typeArr.push(this.value);
347 | 					this.next();
348 | 				} else if (this.eat(tt.bracketL)) {
349 | 					typeArr.push(this.value);
350 | 					this.expect(tt.num);
351 | 					this.expect(tt.bracketR);
352 | 				} else if (this.eat(tok.structType)) {
353 | 					typeArr.push("struct " + this.value);
354 | 					this.expect(tt.name);
355 | 				} else {
356 | 					break;
357 | 				}
358 | 			}
359 | 
360 | 			if (hasName) {
361 | 				node.name = typeArr.pop();
362 | 			}
363 | 
364 | 			let enc = this.jx_parseTypeArr(typeArr, hasName, allowVoid, allowVariadic);
365 | 
366 | 			if (enc === "v" && !allowVoid) {
367 | 				this.raise(this.pos, "The type 'void' is not allowed here");
368 | 			}
369 | 
370 | 			if (enc === "..." && !allowVariadic) {
371 | 				this.raise(this.pos, "Variadic args are not allowed here");
372 | 			}
373 | 
374 | 			node.encoding = enc;
375 | 
376 | 			return this.finishNode(node, "JXType");
377 | 		}
378 | 
379 | 		jx_startTypeAcceptingNode() {
380 | 			const node = this.startNode();
381 | 
382 | 			this.next();
383 | 
384 | 			this.expect(tt.parenL);
385 | 
386 | 			node.jxType = this.jx_parseType(false, false);
387 | 
388 | 			this.expect(tt.parenR);
389 | 
390 | 			return node;
391 | 		}
392 | 
393 | 		jx_parseCast() {
394 | 			const node = this.jx_startTypeAcceptingNode();
395 | 			node.value = this.parseMaybeAssign();
396 | 			return this.finishNode(node, "JXCast");
397 | 		}
398 | 
399 | 		jx_parseEncode() {
400 | 			const node = this.jx_startTypeAcceptingNode();
401 | 			return this.finishNode(node, "JXEncode");
402 | 		}
403 | 
404 | 		jx_parseSizeof() {
405 | 			const node = this.jx_startTypeAcceptingNode();
406 | 			return this.finishNode(node, "JXSizeof");
407 | 		}
408 | 
409 | 		jx_parseStructDef() {
410 | 			const node = this.startNode();
411 | 
412 | 			this.next();
413 | 
414 | 			node.name = this.value;
415 | 			this.expect(tt.name);
416 | 
417 | 			this.expect(tt.braceL);
418 | 
419 | 			node.types = [];
420 | 
421 | 			for (;;) {
422 | 				if (this.eat(tt.braceR)) {
423 | 					break;
424 | 				}
425 | 
426 | 				node.types.push(this.jx_parseType(true, false));
427 | 				this.expect(tt.semi);
428 | 			}
429 | 
430 | 			node.encoding = `{${node.name}=${node.types.map(t => `"${t.name}"${t.encoding}`).join("")}}`;
431 | 
432 | 			this.finishNode(node, "JXStructDef");
433 | 
434 | 			if (!this.structNodes) {
435 | 				this.structNodes = {};
436 | 			}
437 | 			this.structNodes[node.name] = node;
438 | 
439 | 			return node;
440 | 		}
441 | 
442 | 		// called *after* opening parenL. Eats closing parenR
443 | 		jx_parseArgTypeList(hasNames, allowVoid, allowVariadic) {
444 | 			let argTypes = [];
445 | 
446 | 			for (;;) {
447 | 				const argType = this.jx_parseType(hasNames, allowVoid, allowVariadic);
448 | 				argTypes.push(argType);
449 | 				if (this.eat(tt.parenR)) {
450 | 					return argTypes;
451 | 				} else {
452 | 					this.expect(tt.comma);
453 | 				}
454 | 			}
455 | 		}
456 | 
457 | 		jx_parseExternDef() {
458 | 			const node = this.startNode();
459 | 
460 | 			this.next();
461 | 
462 | 			node.value = this.jx_parseType(true, false);
463 | 
464 | 			this.eat(tt.semi);
465 | 
466 | 			return this.finishNode(node, "JXExternDef");
467 | 		}
468 | 
469 | 		jx_parseFuncDef() {
470 | 			const node = this.startNode();
471 | 
472 | 			this.next();
473 | 
474 | 			node.returnType = this.jx_parseType(true, true);
475 | 
476 | 			this.expect(tt.parenL);
477 | 			if (this.eat(tt.parenR)) {
478 | 				node.argTypes = [];
479 | 			} else {
480 | 				node.argTypes = this.jx_parseArgTypeList(false, true, true);
481 | 				// if argTypes contains a void type
482 | 				if (node.argTypes.find(e => e.encoding === "v") !== undefined) {
483 | 					if (node.argTypes.length !== 1) {
484 | 						this.raise(this.pos, "'void' must be the first and only parameter if specified");
485 | 					}
486 | 					node.argTypes = [];
487 | 				}
488 | 			}
489 | 
490 | 			// semicolon isn't required, but if it's there then eat it
491 | 			this.eat(tt.semi);
492 | 
493 | 			return this.finishNode(node, "JXFuncDef");
494 | 		}
495 | 
496 | 		jx_parseBlock() {
497 | 			const node = this.startNode();
498 | 
499 | 			this.enterScope(SCOPE_FUNCTION);
500 | 
501 | 			this.next(); // eat '^'
502 | 
503 | 			if (this.type !== tt.parenL && this.type !== tt.braceL) {
504 | 				// must be the return type
505 | 				node.returnType = this.jx_parseType(false, true);
506 | 			}
507 | 
508 | 			// params is only here to appease parseFunctionBody
509 | 			node.params = [];
510 | 
511 | 			if (this.type !== tt.braceL) {
512 | 				this.expect(tt.parenL);
513 | 				node.argTypes = this.jx_parseArgTypeList(true);
514 | 			} else {
515 | 				node.argTypes = [];
516 | 			}
517 | 
518 | 			this.parseFunctionBody(node, false);
519 | 
520 | 			return this.finishNode(node, "JXBlock")
521 | 		}
522 | 
523 | 		jx_parseMethodDef() {
524 | 			const node = this.startNode();
525 | 
526 | 			this.enterScope(SCOPE_FUNCTION);
527 | 
528 | 			node.isClassMethod = this.value === "+";
529 | 			this.expect(tt.plusMin);
530 | 
531 | 			this.expect(tt.parenL);
532 | 			node.returnType = this.jx_parseType(false, true);
533 | 			this.expect(tt.parenR);
534 | 
535 | 			node.selector = "";
536 | 			node.argTypes = [];
537 | 			node.params = [];
538 | 
539 | 			let isFirstIteration = true;
540 | 			while (true) {
541 | 				node.selector += this.value;
542 | 				this.expect(tt.name);
543 | 				if (isFirstIteration) {
544 | 					if (this.type === tt.braceL) {
545 | 						break;
546 | 					}
547 | 					isFirstIteration = false;
548 | 				}
549 | 				node.selector += ":";
550 | 				this.expect(tt.colon);
551 | 				this.expect(tt.parenL);
552 | 				node.argTypes.push(this.jx_parseType(false));
553 | 				this.expect(tt.parenR);
554 | 
555 | 				node.params.push(this.parseIdent(false));
556 | 
557 | 				if (this.type === tt.braceL) {
558 | 					break;
559 | 				}
560 | 			}
561 | 
562 | 			this.parseFunctionBody(node, false);
563 | 
564 | 			return this.finishNode(node, "JXMethod");
565 | 		}
566 | 
567 | 		// parse class name, allowing dots
568 | 		jx_parseClassName() {
569 | 			let name = this.value;
570 | 			this.expect(tt.name);
571 | 
572 | 			if (this.eat(tt.dot)) {
573 | 				name += "." + this.value;
574 | 				this.expect(tt.name);
575 | 			}
576 | 
577 | 			return name;
578 | 		}
579 | 
580 | 		jx_parseClass() {
581 | 			const node = this.startNode();
582 | 
583 | 			this.next();
584 | 
585 | 			node.className = this.jx_parseClassName();
586 | 
587 | 			this.expect(tt.colon);
588 | 
589 | 			node.superclassName = this.value;
590 | 			this.expect(tt.name);
591 | 
592 | 			if (this.eat(tok.startProtoList)) {
593 | 				const protocols = this.parseExprList(tok.endProtoList, false, false);
594 | 				if (protocols.length === 0) {
595 | 					this.raise(this.pos, "Empty protocol list");
596 | 				}
597 | 				node.protocols = protocols.map(proto => proto.name);
598 | 			}
599 | 
600 | 			if (this.eat(tt.braceL)) {
601 | 				let ivars = [];
602 | 				while (!this.eat(tt.braceR)) {
603 | 					ivars.push(this.jx_parseType(true));
604 | 					this.expect(tt.semi);
605 | 				}
606 | 				node.ivars = ivars;
607 | 			}
608 | 
609 | 			node.methods = [];
610 | 			while (!this.eat(tok.endClass)) {
611 | 				node.methods.push(this.jx_parseMethodDef());
612 | 			}
613 | 
614 | 			return this.finishNode(node, "JXClass");
615 | 		}
616 | 
617 | 		jx_parseHook() {
618 | 			const node = this.startNode();
619 | 
620 | 			this.next();
621 | 
622 | 			node.className = this.jx_parseClassName();
623 | 
624 | 			node.methods = [];
625 | 			while (!this.eat(tok.endHook)) {
626 | 				node.methods.push(this.jx_parseMethodDef());
627 | 			}
628 | 
629 | 			return this.finishNode(node, "JXHook");
630 | 		}
631 | 
632 | 		jx_finishOrigCallNode(node, passAll, values) {
633 | 			node.passAll = passAll;
634 | 			node.values = values;
635 | 			return this.finishNode(node, "JXOrigCall");
636 | 		}
637 | 
638 | 		jx_finishArrayNode(node, elements) {
639 | 			node.elements = elements;
640 | 			return this.finishNode(node, "ArrayExpression");
641 | 		}
642 | 
643 | 		jx_parseOrigCall() {
644 | 			const node = this.startNode();
645 | 
646 | 			this.next();
647 | 
648 | 			if (!this.eat(tt.parenL)) {
649 | 				return this.jx_finishOrigCallNode(node, true, null);
650 | 			} else {
651 | 				const values = this.parseExprList(tt.parenR, true, true);
652 | 				return this.jx_finishOrigCallNode(node, false, values);
653 | 			}
654 | 		}
655 | 
656 | 		jx_parseLiteral(startPos, startLoc, refDestructuringErrors) {
657 | 			const node = this.startNodeAt(startPos, startLoc);
658 | 
659 | 			if (this.type === tt.braceL) {
660 | 				// object literal
661 | 				node.value = this.parseObj();
662 | 			} else if (this.type === tt.bracketL) {
663 | 				// array literal
664 | 				const arrayNode = this.startNode();
665 | 				this.next();
666 | 				let elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors);
667 | 				node.value = this.jx_finishArrayNode(arrayNode, elements);
668 | 			} else if (this.type === tt.num || this.type === tt.string || this.type === tt._true || this.type === tt._false) {
669 | 				// numeric, string, or boolean literal
670 | 				node.value = this.parseLiteral();
671 | 			} else if (this.type === tok.yes) {
672 | 				node.value = this.jx_parseBooleanLiteral(true);
673 | 			} else if (this.type == tok.no) {
674 | 				node.value = this.jx_parseBooleanLiteral(false);
675 | 			} else {
676 | 				this.raise(this.pos, "Expected object, array, numeric, string, or boolean literal");
677 | 			}
678 | 
679 | 			return this.finishNode(node, "JXLiteral");
680 | 		}
681 | 
682 | 		jx_parseBox(startPos, startLoc) {
683 | 			const node = this.startNodeAt(startPos, startLoc);
684 | 
685 | 			this.expect(tt.parenL);
686 | 			node.value = this.parseExpression();
687 | 			this.expect(tt.parenR);
688 | 
689 | 			return this.finishNode(node, "JXBox");
690 | 		}
691 | 
692 | 		// bracketR might also refer to an array, so this distinguishes between the two
693 | 		jx_parseMaybeMethodCall(refDestructuringErrors) {
694 | 			const node = this.startNode();
695 | 
696 | 			this.next();
697 | 
698 | 			// if we immediately see a right bracket, then it's an empty array
699 | 			if (this.eat(tt.bracketR)) {
700 | 				return this.jx_finishArrayNode(node, []);
701 | 			}
702 | 
703 | 			// if it isn't an empty array, then whether or not it's a method call or an array,
704 | 			// it will definitely have a first element/target, so fetch that.
705 | 			let expr;
706 | 			// if the token is "super", set the method's target to null
707 | 			if (this.type === tt._super) {
708 | 				this.next();
709 | 				expr = null;
710 | 			} else {
711 | 				expr = this.parseMaybeAssign();
712 | 			}
713 | 
714 | 			// now, if we see a comma or a right bracket, then it's an array
715 | 			if (this.eat(tt.comma) || this.type === tt.bracketR) {
716 | 				// get the remaining elements of the array and add expr to the start
717 | 				let elements = this.parseExprList(tt.bracketR, true, true, refDestructuringErrors);
718 | 				elements.unshift(expr);
719 | 				return this.jx_finishArrayNode(node, elements);
720 | 			}
721 | 
722 | 			// otherwise it's a method call
723 | 			return this.jx_parseMethodCall(node, expr);
724 | 		}
725 | 
726 | 		jx_parseMethodCall(node, target) {
727 | 			node.target = target;
728 | 			node.selector = "";
729 | 			node.args = [];
730 | 
731 | 			let isFirstIteration = true;
732 | 			for (;;) {
733 | 				let selPart = this.parseIdent(true);
734 | 				node.selector += selPart.name;
735 | 				if (isFirstIteration) {
736 | 					if (this.eat(tt.bracketR)) {
737 | 						break;
738 | 					}
739 | 					isFirstIteration = false;
740 | 				}
741 | 				this.expect(tt.colon);
742 | 				node.selector += ":";
743 | 				node.args.push(this.parseExpression());
744 | 				if (this.eat(tt.bracketR)) {
745 | 					break;
746 | 				}
747 | 			}
748 | 
749 | 			return this.finishNode(node, "JXMethodCall");
750 | 		}
751 | 	};
752 | }
753 | 


--------------------------------------------------------------------------------
/src/fs.js:
--------------------------------------------------------------------------------
1 | // intentionally left blank
2 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
 1 | const acorn = require("acorn");
 2 | const acornJX = require("./acorn-jx.js");
 3 | const acornJXParser = acorn.Parser.extend(acornJX());
 4 | 
 5 | function uglifyCode(source) {
 6 | 	require('../uglify.js');
 7 | 	const options = {
 8 | 		compress: {
 9 | 			// disable converting to arrow funcs, as the `arguments` var can't be accessed in them
10 | 			reduce_funcs: false,
11 | 			// disable removal of unused vars, including where a func argument is modified without being
12 | 			// accessed elsewhere. Required because UglifyJS doesn't count the `arguments` var as a "use"
13 | 			unused: false
14 | 		},
15 | 		sourceMap: {
16 | 			content: source.map,
17 | 			url: "uglify.js.map"
18 | 		}
19 | 	};
20 | 	return UglifyJS.minify(source.code, options);
21 | }
22 | 
23 | module.exports.transpile = function(source, minify = false) {
24 | 	const MOZ_SourceMap = require("source-map");
25 | 	const recast = require("recast");
26 | 	const recastJX = require("./recast-jx.js");
27 | 	const recastAcornParser = require("./recast-acorn-parser.js");
28 | 	const recastAcornJXParser = recastAcornParser(acornJXParser);
29 | 	const babel = require("@babel/core");
30 | 
31 | 	let ast = recast.parse(source, {
32 | 		parser: recastAcornJXParser,
33 | 		sourceFileName: "main.objs"
34 | 	});
35 | 	recastJX(ast);
36 | 	let result = recast.print(ast, {
37 | 		sourceMapName: "recast.js.map"
38 | 	});
39 | 	result = babel.transform(result.code, {
40 | 		inputSourceMap: result.map,
41 | 		sourceMaps: true,
42 | 		sourceFileName: "babel.js.map",
43 | 		sourceType: "script",
44 |   		presets: [
45 |   			[
46 |   				require("@babel/preset-env"),
47 |   				{
48 |   					"targets": "iOS 9"
49 |   				}
50 |   			]
51 |   		]
52 | 	});
53 | 
54 | 	if (minify) {
55 | 		result = uglifyCode(result);
56 | 	}
57 | 	result.map = JSON.stringify(result.map);
58 | 	return result;
59 | }
60 | 
61 | module.exports.tokenize = function(source) {
62 | 	return acornJXParser.tokenizer(source);
63 | }
64 | 


--------------------------------------------------------------------------------
/src/recast-acorn-parser.js:
--------------------------------------------------------------------------------
 1 | function parse(parser, source, options) {
 2 | 	const comments = [];
 3 | 	const tokens = [];
 4 | 	const ast = parser.parse(source, {
 5 | 		locations: true,
 6 | 		onComment: comments,
 7 | 		onToken: tokens,
 8 | 	});
 9 | 
10 | 	if (!ast.comments) {
11 | 		ast.comments = comments;
12 | 	}
13 | 
14 | 	if (!ast.tokens) {
15 | 		ast.tokens = tokens;
16 | 	}
17 | 
18 | 	return ast;
19 | }
20 | 
21 | // create a recast-compatible parser from an Acorn parser
22 | module.exports = function(parser) {
23 | 	return {
24 | 		parse: function(source, options) {
25 | 			return parse(parser, source, options);
26 | 		}
27 | 	};
28 | }
29 | 


--------------------------------------------------------------------------------
/src/recast-jx.js:
--------------------------------------------------------------------------------
  1 | // modifies OBJS AST to regular JS
  2 | 
  3 | const recast = require("recast");
  4 | const b = recast.types.builders;
  5 | require("./types-jx.js")();
  6 | 
  7 | function makeBoxExpression(object) {
  8 | 	return b.callExpression(b.identifier("box"), [object]);
  9 | }
 10 | 
 11 | function makeTraversalFunction(traversalFunction) {
 12 | 	return function(path) {
 13 | 		this.traverse(path);
 14 | 		return traversalFunction(path.node);
 15 | 	};
 16 | }
 17 | 
 18 | module.exports = function(ast) {
 19 | 	recast.visit(ast, {
 20 | 		visitJXMethodCall: makeTraversalFunction(function(methodCall) {
 21 | 			let target;
 22 | 			let selector;
 23 | 			if (methodCall.target === null) {
 24 | 				target = b.identifier("self");
 25 | 				selector = "^" + methodCall.selector;
 26 | 			} else {
 27 | 				target = methodCall.target;
 28 | 				selector = "@" + methodCall.selector;
 29 | 			}
 30 | 			const selExpr = b.memberExpression(target, b.literal(selector), true);
 31 | 			const selCall = b.callExpression(selExpr, methodCall.args);
 32 | 			return selCall;
 33 | 		}),
 34 | 
 35 | 		visitJXBox: makeTraversalFunction(function(box) {
 36 | 			return makeBoxExpression(box.value);
 37 | 		}),
 38 | 
 39 | 		visitJXBoolean: makeTraversalFunction(function(boolean) {
 40 | 			return b.literal(boolean.value);
 41 | 		}),
 42 | 
 43 | 		visitJXLiteral: makeTraversalFunction(function(literal) {
 44 | 			return makeBoxExpression(literal.value);
 45 | 		}),
 46 | 
 47 | 		visitJXOrigCall: makeTraversalFunction(function(call) {
 48 | 			let args;
 49 | 			if (call.passAll) {
 50 | 				args = [b.identifier("arguments")];
 51 | 			} else {
 52 | 				args = [b.arrayExpression(call.values)];
 53 | 			}
 54 | 			return b.callExpression(b.identifier("orig"), args);
 55 | 		}),
 56 | 
 57 | 		visitJXClass: makeTraversalFunction(function(cls) {
 58 | 			return b.expressionStatement(b.callExpression(b.identifier("defineClass"), [
 59 | 				b.literal(cls.className),
 60 | 				b.literal(cls.superclassName),
 61 | 				b.arrayExpression(cls.protocols.map(p => b.literal(p))),
 62 | 				b.objectExpression(cls.ivars.map(p => b.property("init", b.literal(p.name), b.literal(p.encoding)))),
 63 | 				b.objectExpression(cls.methods),
 64 | 			]));
 65 | 		}),
 66 | 
 67 | 		visitJXHook: makeTraversalFunction(function(hook) {
 68 | 			return b.expressionStatement(b.callExpression(b.identifier("hookClass"), [
 69 | 				b.literal(hook.className),
 70 | 				b.objectExpression([]),
 71 | 				b.objectExpression(hook.methods)
 72 | 			]));
 73 | 		}),
 74 | 
 75 | 		visitJXMethod: makeTraversalFunction(function(method) {
 76 | 			// @ and : are for id self and SEL _cmd, the "hidden" arguments in an objc method
 77 | 			const sig = `${method.returnType.encoding}@:${method.argTypes.map(t => t.encoding).join("")}`;
 78 | 			const key = `${sig}${method.isClassMethod ? "+" : "-"}${method.selector}`;
 79 | 			return b.property("init", b.literal(key), b.functionExpression(null, method.params, method.body));
 80 | 		}),
 81 | 
 82 | 		visitJXBlock: makeTraversalFunction(function(block) {
 83 | 			let retEncoding;
 84 | 			if (block.returnType === null) {
 85 | 				retEncoding = "v";
 86 | 			} else {
 87 | 				retEncoding = block.returnType.encoding;
 88 | 			}
 89 | 			// @? represents the block
 90 | 			const sig = `${retEncoding}@?${block.argTypes.map(t => t.encoding).join("")}`;
 91 | 			return b.callExpression(b.identifier("defineBlock"), [
 92 | 				b.literal(sig),
 93 | 				b.functionExpression(null, block.argTypes.map(t => b.identifier(t.name)), block.body)
 94 | 			]);
 95 | 		}),
 96 | 
 97 | 		visitJXFuncDef: makeTraversalFunction(function(def) {
 98 | 			let sig = def.returnType.encoding;
 99 | 			sig += def.argTypes.map(t => t.encoding).join("");
100 | 
101 | 			return b.expressionStatement(b.callExpression(b.identifier("loadFunc"), [
102 | 				b.literal(def.returnType.name),
103 | 				b.literal(sig),
104 | 				b.literal(true)
105 | 			]));
106 | 		}),
107 | 
108 | 		visitJXExternDef: makeTraversalFunction(function(def) {
109 | 			return b.expressionStatement(b.callExpression(b.identifier("loadSymbol"), [
110 | 				b.literal(def.value.name),
111 | 				b.literal(def.value.encoding),
112 | 				b.literal(true)
113 | 			]))
114 | 		}),
115 | 
116 | 		visitJXDeref: makeTraversalFunction(function(deref) {
117 | 			return b.memberExpression(deref.argument, b.identifier("pointee"))
118 | 		}),
119 | 
120 | 		visitJXRef: makeTraversalFunction(function(ref) {
121 | 			return b.callExpression(b.identifier("getRef"), [b.literal(ref.value)]);
122 | 		}),
123 | 
124 | 		visitJXStructDef: makeTraversalFunction(function(def) {
125 | 			return b.expressionStatement(b.callExpression(b.identifier("defineStruct"), [
126 | 				b.literal(def.name),
127 | 				b.literal(def.encoding)
128 | 			]));
129 | 		}),
130 | 
131 | 		visitJXSizeof: makeTraversalFunction(function(expr) {
132 | 			return b.callExpression(b.identifier("sizeof"), [b.literal(expr.jxType.encoding)]);
133 | 		}),
134 | 
135 | 		visitJXEncode: makeTraversalFunction(function(expr) {
136 | 			return b.literal(expr.jxType.encoding);
137 | 		}),
138 | 
139 | 		visitJXCast: makeTraversalFunction(function(cast) {
140 | 			return b.callExpression(b.identifier("cast"), [
141 | 				b.literal(cast.jxType.encoding),
142 | 				cast.value
143 | 			]);
144 | 		}),
145 | 	});
146 | };
147 | 


--------------------------------------------------------------------------------
/src/types-jx.js:
--------------------------------------------------------------------------------
  1 | // Definitions for OBJS AST types
  2 | 
  3 | const types = require("ast-types");
  4 | const Type = types.Type;
  5 | const def = Type.def;
  6 | const or = Type.or;
  7 | 
  8 | module.exports = function() {
  9 | 	def("JXMethodCall")
 10 | 		.bases("Expression")
 11 | 		.field("target", or(def("Expression"), null))
 12 | 		.field("selector", String)
 13 | 		.field("args", [def("Expression")])
 14 | 		.finalize();
 15 | 
 16 | 	def("JXBox")
 17 | 		.bases("Expression")
 18 | 		.field("value", def("Expression"))
 19 | 		.finalize();
 20 | 
 21 | 	def("JXLiteral")
 22 | 		.bases("Literal")
 23 | 		.field("value", or(def("Literal"), def("JXBoolean")))
 24 | 		.finalize();
 25 | 
 26 | 	def("JXBoolean")
 27 | 		.bases("Literal")
 28 | 		.field("value", Boolean)
 29 | 		.finalize();
 30 | 
 31 | 	def("JXOrigCall")
 32 | 		.bases("Expression")
 33 | 		.field("passAll", Boolean)
 34 | 		.field("values", [def("Expression")])
 35 | 		.finalize();
 36 | 
 37 | 	def("JXType")
 38 | 		.bases("Node")
 39 | 		.field("encoding", String)
 40 | 		.field("name", String)
 41 | 		.finalize();
 42 | 
 43 | 	def("JXBlock")
 44 | 		.bases("Expression")
 45 | 		.field("returnType", or(def("JXType"), null), () => null)
 46 | 		.field("argTypes", [def("JXType")])
 47 |         .field("body", def("BlockStatement"))
 48 | 		.finalize();
 49 | 
 50 | 	def("JXMethod")
 51 | 		.bases("Node")
 52 | 		.field("isClassMethod", Boolean)
 53 | 		.field("selector", String)
 54 | 		.field("returnType", def("JXType"))
 55 | 		.field("argTypes", [def("JXType")])
 56 | 		.field("params", [def("Pattern")])
 57 |         .field("body", def("BlockStatement"))
 58 | 		.finalize();
 59 | 
 60 | 	def("JXClass")
 61 | 		.bases("Node")
 62 | 		.field("className", String)
 63 | 		.field("superclassName", String)
 64 | 		.field("protocols", [String], () => [])
 65 | 		.field("ivars", [def("JXType")], () => [])
 66 | 		.field("methods", [def("JXMethod")], () => [])
 67 | 		.finalize();
 68 | 
 69 | 	def("JXHook")
 70 | 		.bases("Node")
 71 | 		.field("className", String)
 72 | 		.field("methods", [def("JXMethod")], () => [])
 73 | 		.finalize();
 74 | 
 75 | 	def("JXFuncDef")
 76 | 		.bases("Statement")
 77 | 		.field("returnType", def("JXType"))
 78 | 		.field("argTypes", [def("JXType")])
 79 | 		.finalize();
 80 | 
 81 | 	def("JXExternDef")
 82 | 		.bases("Statement")
 83 | 		.field("value", def("JXType"))
 84 | 		.finalize();
 85 | 
 86 | 	def("JXDeref")
 87 | 		.bases("Expression")
 88 | 		.field("argument", def("Expression"))
 89 | 		.finalize();
 90 | 
 91 | 	def("JXRef")
 92 | 		.bases("Expression")
 93 | 		.field("value", String)
 94 | 		.finalize();
 95 | 
 96 | 	// used at both runtime and compile time
 97 | 	def("JXStructDef")
 98 | 		.bases("Statement")
 99 | 		.field("name", String)
100 | 		.field("types", [def("JXType")])
101 | 		.finalize();
102 | 
103 | 	def("JXSizeof")
104 | 		.bases("Expression")
105 | 		.field("jxType", def("JXType"))
106 | 		.finalize();
107 | 
108 | 	def("JXEncode")
109 | 		.bases("Expression")
110 | 		.field("jxType", def("JXType"))
111 | 		.finalize();
112 | 
113 | 	def("JXCast")
114 | 		.bases("Expression")
115 | 		.field("jxCast", def("JXType"))
116 | 		.field("value", def("Expression"))
117 | 		.finalize();
118 | }
119 | 


--------------------------------------------------------------------------------
/test/app.objs:
--------------------------------------------------------------------------------
  1 | const UIBarButtonSystemItem = Object.freeze({
  2 | 	add: 4
  3 | });
  4 | 
  5 | const UITableViewRowAnimation = Object.freeze({
  6 | 	automatic: 100
  7 | });
  8 | 
  9 | const UITableViewCellStyle = Object.freeze({
 10 | 	default: 0
 11 | });
 12 | 
 13 | @class MyOtherViewController : UIViewController <UITableViewDelegate, UITableViewDataSource> {
 14 | 	id _objects;
 15 | }
 16 | 
 17 | @end
 18 | 
 19 | @class MyViewController : UITableViewController {
 20 | 	id _objects;
 21 | }
 22 | 
 23 | - (void)viewDidLoad {
 24 | 	[super viewDidLoad];
 25 | 	self.title = "Root View Controller";
 26 | 	self.navigationItem.leftBarButtonItem = self.editButtonItem;
 27 | 	const item = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:4 target:self action:"addButtonTapped:"];
 28 | 	self.navigationItem.rightBarButtonItem = item;
 29 | 	_objects = [NSMutableArray array];
 30 | }
 31 | 
 32 | - (void)addButtonTapped:(id)sender {
 33 | 	[_objects insertObject:new Date() atIndex:0];
 34 | 	const path = [NSIndexPath indexPathForRow:0 inSection:0];
 35 | 	[self.tableView insertRowsAtIndexPaths:[path] withRowAnimation:UITableViewRowAnimation.automatic];
 36 | }
 37 | 
 38 | // MARK:- Table View Data Source
 39 | 
 40 | - (long)tableView:(id)tableView numberOfRowsInSection:(long)section {
 41 | 	return _objects.count;
 42 | }
 43 | 
 44 | - (id)tableView:(id)tableView cellForRowAtIndexPath:(id)indexPath {
 45 | 	let cell = [tableView dequeueReusableCellWithIdentifier:"cell"];
 46 | 	if (!cell) {
 47 | 		cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyle.default reuseIdentifier:"cell"];
 48 | 	}
 49 | 	const date = _objects[indexPath.row];
 50 | 	cell.textLabel.text = "" + date;
 51 | 	return cell;
 52 | }
 53 | 
 54 | - (void)tableView:(id)tableView commitEditingStyle:(long)editingStyle forRowAtIndexPath:(id)indexPath {
 55 | 	[_objects removeObjectAtIndex:indexPath.row];
 56 | 	NSLog(@(unbox(@{"foo": 10, "bar": indexPath})));
 57 | 	[tableView deleteRowsAtIndexPaths:[indexPath] withRowAnimation:UITableViewRowAnimation.automatic];
 58 | }
 59 | 
 60 | // MARK:- Table View Delegate
 61 | 
 62 | - (void)tableView:(id)tableView didSelectRowAtIndexPath:(id)indexPath {
 63 | 	[tableView deselectRowAtIndexPath:indexPath animated:YES];
 64 | }
 65 | 
 66 | - (void)dealloc {
 67 | 	NSLog("Bye!");
 68 | }
 69 | 
 70 | @end
 71 | 
 72 | @class BaseClass: NSObject
 73 | 
 74 | - (id)init {
 75 | 	self = [super init];
 76 | 	if (self) {
 77 | 		NSLog("Base init called!");
 78 | 	}
 79 | 	return self;
 80 | }
 81 | 
 82 | - (void)dealloc {
 83 | 	NSLog("Base dealloc!");
 84 | }
 85 | 
 86 | @end
 87 | 
 88 | @class AClass : BaseClass {
 89 | 	id foo;
 90 | }
 91 | 
 92 | - (id)initWithMsg:(id)msg {
 93 | 	self = [super init];
 94 | 	if (self) {
 95 | 		foo = "stored ivar";
 96 | 		NSLog(msg);
 97 | 	}
 98 | 	return self;
 99 | }
100 | 
101 | - (void)dealloc {
102 | 	NSLog("AClass instance getting dealloc'd!");
103 | }
104 | 
105 | - (BOOL)someFunc {
106 | 	NSLog(foo);
107 | 	return (1 + 1 == 2);
108 | }
109 | 
110 | @end
111 | 
112 | let block = ^int(id str) {
113 | 	NSLog("Block received message: " + str);
114 | 	return 10;
115 | };
116 | NSLog("Custom block call: " + block("Custom!"));
117 | 
118 | [HackObjC someFuncWithBlock:block];
119 | 
120 | @struct CGSize {
121 | 	double width;
122 | 	double height;
123 | }
124 | 
125 | @struct CGPoint {
126 | 	double x;
127 | 	double y;
128 | }
129 | 
130 | @struct CGRect {
131 | 	struct CGPoint origin;
132 | 	struct CGSize size;
133 | }
134 | 
135 | @struct idk {
136 | 	int[2] foo;
137 | }
138 | // ^ should compile to "{idk=\"foo\"[2i]}"
139 | 
140 | @function void free(void *);
141 | @function void *calloc(unsigned long, unsigned long);
142 | @function int strcmp(char *, char *);
143 | @function int printf(char *, ...);
144 | 
145 | @extern char **environ;
146 | 
147 | NSLog("Environ address: " + &environ)
148 | 
149 | var environArr = [];
150 | for (let i = 0;;i++) {
151 | 	let element = environ[i];
152 | 	if (element === null) break;
153 | 	environArr.push(element);
154 | }
155 | 
156 | NSLog("Environ: " + environArr);
157 | 
158 | var pointer = Pointer(@encode(id));
159 | *pointer = "Hello";
160 | [HackObjC somePtrAcceptor:pointer];
161 | free(pointer);
162 | pointer = null;
163 | 
164 | var ptr2 = Pointer(@encode(int));
165 | *ptr2 = 10;
166 | [HackObjC somePtrSetter:ptr2];
167 | NSLog("Ptr setter set: " + *ptr2);
168 | // free(ptr2);
169 | 
170 | var ptr3 = [HackObjC somePtrReturner];
171 | NSLog("Ptr returner returned: " + *ptr3);
172 | var dist = ptr2.distanceTo(ptr3);
173 | NSLog("Actual Dist: " + dist);
174 | // NSLog("Dist+1: " + dist.decimalNumberByAdding(NSDecimalNumber.one()));
175 | ptr2[ptr2.distanceTo(ptr3)] = 57;
176 | NSLog("3rd with offset from 2nd: " + ptr2[ptr2.distanceTo(ptr3)]);
177 | free(ptr3);
178 | free(ptr2);
179 | NSLog("Freed should be weird: " + *ptr3);
180 | 
181 | var strct = [HackObjC someStructReturner];
182 | strct.foo[0] = 123;
183 | NSLog(Array.from(strct.foo));
184 | 
185 | let vc = [[AClass alloc] initWithMsg:"This is a message"];
186 | NSLog([vc someFunc]);
187 | vc = null;
188 | 
189 | let arr = [NSMutableArray array];
190 | [arr addObject:@"hi"];
191 | NSLog("arr object: " + arr[0]);
192 | arr[0] = @"bye";
193 | NSLog("new arr object: " + arr[0]);
194 | 
195 | NSLog(@NO);
196 | 
197 | @function void *dlopen(char *, int);
198 | @function void *dlsym(void *, char *);
199 | 
200 | @extern void *_dispatch_main_q;
201 | @function void dispatch_async(id, id);
202 | 
203 | dlopen("/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication", 0x00001 /* RTLD_LAZY */);
204 | 
205 | %hook NSBundle
206 | 
207 | - (id)infoDictionary {
208 | 	// if (!orig) {
209 | 	// 	NSLog("big oof! " + self);
210 | 	// 	return;
211 | 	// }
212 | 	const dict = [%orig mutableCopy];
213 | 	[dict setObject:"Please authenticate" forKey:"NSFaceIDUsageDescription"];
214 | 	// NSLog(dict);
215 | 	return dict.copy;
216 | }
217 | 
218 | %end
219 | 
220 | let hasSucceeded = false;
221 | 
222 | %hook SuperchargerTests.AppDelegate
223 | 
224 | // - (void)applicationDidBecomeActive:(id)application {
225 | // 	if (hasSucceeded) return;
226 | // 	let context = [LAContext new];
227 | // 	context.localizedCancelTitle = "Cancel";
228 | // 	[context evaluatePolicy:1 localizedReason:"Please authenticate" reply:^(BOOL success, id error) {
229 | // 		if (success) {
230 | // 			hasSucceeded = true;
231 | // 		} else {
232 | // 			dispatch_async(&_dispatch_main_q, ^{
233 | // 				[UIApplication.sharedApplication suspend];
234 | // 			});
235 | // 		}
236 | // 	}];
237 | // }
238 | 
239 | - (void)someNewFunction {
240 | 	NSLog("New function called!");
241 | }
242 | 
243 | - (BOOL)application:(id)application didFinishLaunchingWithOptions:(id)launchOptions {
244 | 	const ret = %orig;
245 | 	try {
246 | 		NSLog(arr[2]);
247 | 	} catch (e) {
248 | 		NSLog("JS EXCEPTION RAISED!");
249 | 		NSLog(e.message);
250 | 		NSLog("JS EXCEPTION END");
251 | 	}
252 | 
253 | 	// [NSString idk];
254 | 	// NSLog(resourcesPath);
255 | 
256 | 	NSLog(strcmp("hello", "henlo"));
257 | 	printf("one plus one equals %u\ntwo plus two is (text): %s\n", @cast(unsigned int)(1+1), @cast(char *)("four"));
258 | 
259 | 	// const boundsPtr = Pointer(@encode(struct CGRect), true);
260 | 	const boundsPtr = @cast(struct CGRect *)calloc(1, @sizeof(struct CGRect));
261 | 	(*boundsPtr).size.width = 1234;
262 | 	NSLog(*boundsPtr);
263 | 
264 | 	NSLog(@[[NSNull null], [UIColor colorWithRed:1 green:0.5 blue:0 alpha:0]]);
265 | 
266 | 	[self someNewFunction];
267 | 
268 | 	return ret;
269 | }
270 | 
271 | %end
272 | 
273 | %hook SuperchargerTests.ViewController
274 | 
275 | - (void)sayHelloWithArg1:(id)arg1 arg2:(id)arg2 {
276 | 	NSLog("say hello called!");
277 | 	var origFunc = orig;
278 | 	var alert = [global.UIAlertController alertControllerWithTitle:"hello" message:"hi" preferredStyle:1];
279 | 	[alert addAction:[UIAlertAction actionWithTitle:"do something" style:1 handler:^(id int) {
280 | 		origFunc([arg1, arg2]);
281 | 		const window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds];
282 | 		UIApplication.sharedApplication.delegate.window = window;
283 | 		let vc = [MyViewController new];
284 | 		const nav = [[UINavigationController alloc] initWithRootViewController:vc];
285 | 		window.rootViewController = nav;
286 | 		[window makeKeyAndVisible];
287 | 	}]];
288 | 	[self presentViewController:alert animated:YES completion:null];
289 | }
290 | 
291 | %end
292 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | const _transpile = require('../src/index.js').transpile;
  2 | const transpile = (code) => _transpile(code).code;
  3 | 
  4 | const fs = require('fs');
  5 | const assert = require('assert');
  6 | 
  7 | // TODO: Add tests for errors
  8 | 
  9 | describe("OBJSTranspiler", function() {
 10 | 	describe("JXMethodCall", function() {
 11 | 		describe("without arguments", function() {
 12 | 			it("should compile simple cases correctly", function() {
 13 | 				let code = transpile("[NSDate date]");
 14 | 				assert.equal(code, 'NSDate["@date"]();');
 15 | 			});
 16 | 			it("should allow JS keywords to be used as selectors", function() {
 17 | 				let code = transpile("[NSArray new]");
 18 | 				assert.equal(code, 'NSArray["@new"]();');
 19 | 			});
 20 | 			it("should work with super calls", function() {
 21 | 				let code = transpile("[super init]");
 22 | 				assert.equal(code, 'self["^init"]();');
 23 | 			});
 24 | 			it("should allow expressions to be used as targets", function() {
 25 | 				let code = transpile('[foo+bar baz]');
 26 | 				assert.equal(code, '(foo + bar)["@baz"]();');
 27 | 			});
 28 | 			it("should allow other method calls to be used as targets", function() {
 29 | 				let code = transpile("[[NSArray alloc] init]");
 30 | 				assert.equal(code, 'NSArray["@alloc"]()["@init"]();');
 31 | 			});
 32 | 		});
 33 | 		describe("with arguments", function() {
 34 | 			it("should compile simple single-argument cases correctly", function() {
 35 | 				let code = transpile('[UIImage imageNamed:"Foo"]');
 36 | 				assert.equal(code, 'UIImage["@imageNamed:"]("Foo");');
 37 | 			});
 38 | 			it("should compile simple multi-argument cases correctly", function() {
 39 | 				let code = transpile('[Foo fooWithBar:"a" baz:"b"]');
 40 | 				assert.equal(code, 'Foo["@fooWithBar:baz:"]("a", "b");');
 41 | 			});
 42 | 			it("should work with super calls", function() {
 43 | 				let code = transpile('[super initWithBar:"a" baz:"b"]');
 44 | 				assert.equal(code, 'self["^initWithBar:baz:"]("a", "b");');
 45 | 			});
 46 | 			it("should allow expressions to be used as arguments", function() {
 47 | 				let code = transpile('[Foo fooWithBar:"a"+"b" baz:"c"]');
 48 | 				assert.equal(code, 'Foo["@fooWithBar:baz:"]("a" + "b", "c");');
 49 | 			})
 50 | 			it("should allow other method calls to be used as arguments", function() {
 51 | 				let code = transpile('[Foo fooWithBar:[Bar new] baz:[Baz bazWithArg:0]]');
 52 | 				assert.equal(code, 'Foo["@fooWithBar:baz:"](Bar["@new"](), Baz["@bazWithArg:"](0));');
 53 | 			})
 54 | 		});
 55 | 		describe("array handling", function() {
 56 | 			function assertPassthrough(code) {
 57 | 				assert.equal(transpile(code), code);
 58 | 			}
 59 | 			it("should not detect arrays as method calls", function() {
 60 | 				let code = transpile('[foo, bar]');
 61 | 				assert.equal(code, '[foo, bar];');
 62 | 			});
 63 | 			it("should allow trailing commas in arrays", function() {
 64 | 				let code = transpile('[foo,]');
 65 | 				assert.equal(code, '[foo];');
 66 | 			});
 67 | 			it("should allow single-element arrays", function() {
 68 | 				let code = transpile('[foo]');
 69 | 				assert.equal(code, '[foo];');
 70 | 			});
 71 | 			it("should allow empty arrays", function() {
 72 | 				let code = transpile('[]');
 73 | 				assert.equal(code, '[];');
 74 | 			});
 75 | 			it("should allow subscripts", function() {
 76 | 				let code = transpile('[foo, bar][0]');
 77 | 				assert.equal(code, '[foo, bar][0];');
 78 | 			});
 79 | 			it("should allow method calls to be nested in arrays", function() {
 80 | 				let code = transpile('[foo, [Bar baz]]');
 81 | 				assert.equal(code, '[foo, Bar["@baz"]()];');
 82 | 			});
 83 | 			it("should allow arrays to be nested in method calls", function() {
 84 | 				let code = transpile('[Foo fooWithBar:[baz]]');
 85 | 				assert.equal(code, 'Foo["@fooWithBar:"]([baz]);');
 86 | 			});
 87 | 		});
 88 | 	});
 89 | });
 90 | 
 91 | // function describeCode(message, code, execute) {
 92 | // 	describe(message, function() {
 93 | // 		before(function() {
 94 | // 			this.code = transpile(code);
 95 | // 		});
 96 | 
 97 | // 		execute();
 98 | // 	});
 99 | // }
100 | 
101 | // describe('OBJSTranspiler', function() {
102 | 
103 | // 	// describe('msgSend', function() {
104 | // 	// 	describeCode('without args', '$[foo bar];', [
105 | // 	// 		{
106 | // 	// 			it: 'should have the right target',
107 | // 	// 			foo: 1,
108 | // 	// 			msgSend: function (target, sel, ...args) {
109 | // 	// 				assert.equal(target, 1);
110 | // 	// 			}
111 | // 	// 		},
112 | // 	// 		{
113 | // 	// 			it: 'should have the right selector',
114 | // 	// 			foo: 1,
115 | // 	// 			msgSend: function (target, sel, ...args) {
116 | // 	// 				assert.equal(sel, 'bar');
117 | // 	// 			}
118 | // 	// 		},
119 | // 	// 		{
120 | // 	// 			it: 'should have no args',
121 | // 	// 			foo: 1,
122 | // 	// 			msgSend: function (target, sel, ...args) {
123 | // 	// 				assert.equal(args.length, 0);
124 | // 	// 			}
125 | // 	// 		}
126 | // 	// 	]);
127 | 
128 | // 	// 	describeCode('with args', '$[foo barWithA:10 b:"hello"];', [
129 | // 	// 		{
130 | // 	// 			it: 'should have the right target',
131 | // 	// 			foo: 1,
132 | // 	// 			msgSend: function (target, sel, ...args) {
133 | // 	// 				assert.equal(target, 1);
134 | // 	// 			}
135 | // 	// 		},
136 | // 	// 		{
137 | // 	// 			it: 'should have the right selector',
138 | // 	// 			foo: 1,
139 | // 	// 			msgSend: function (target, sel, ...args) {
140 | // 	// 				assert.equal(sel, 'barWithA:b:');
141 | // 	// 			}
142 | // 	// 		},
143 | // 	// 		{
144 | // 	// 			it: 'should have the right args',
145 | // 	// 			foo: 1,
146 | // 	// 			msgSend: function (target, sel, ...args) {
147 | // 	// 				assert.equal(args[0], 10);
148 | // 	// 				assert.equal(args[1], "hello");
149 | // 	// 			}
150 | // 	// 		}
151 | // 	// 	]);
152 | 
153 | // 	// 	describeCode('with an expression target', '$["hello"+foo bar];', [
154 | // 	// 		{
155 | // 	// 			it: 'should have the right target',
156 | // 	// 			foo: "!",
157 | // 	// 			msgSend: function (target, sel, ...args) {
158 | // 	// 				assert.equal(target, 'hello!');
159 | // 	// 			}
160 | // 	// 		}
161 | // 	// 	]);
162 | 
163 | // 	// 	describeCode('with an expression argument', '$[foo barWithA:b+c];', [
164 | // 	// 		{
165 | // 	// 			it: 'should have one, correct arg',
166 | // 	// 			foo: 1,
167 | // 	// 			b: 5,
168 | // 	// 			c: 6,
169 | // 	// 			msgSend: function (target, sel, ...args) {
170 | // 	// 				assert.equal(args.length, 1, "args.length != 1");
171 | // 	// 				assert.equal(args[0], 11, "args[0] != 11");
172 | // 	// 			}
173 | // 	// 		}
174 | // 	// 	]);
175 | 
176 | // 	// 	describeCode('with new as a target', '$[Foo new]', [
177 | // 	// 		{
178 | // 	// 			it: 'should have its selector set to `new`',
179 | // 	// 			Foo: 1,
180 | // 	// 			msgSend: function (target, sel, ...args) {
181 | // 	// 				assert.equal(sel, 'new');
182 | // 	// 			}
183 | // 	// 		}
184 | // 	// 	]);
185 | 
186 | // 	// 	// TODO: Add tests for super
187 | // 	// });
188 | 
189 | // 	// describe('associatedObject', function() {
190 | // 	// 	describeCode('getter', '$(_foo);', [
191 | // 	// 		{
192 | // 	// 			it: 'should have self as its target',
193 | // 	// 			self: 10,
194 | // 	// 			associatedObject: function (target, name, val) {
195 | // 	// 				assert.equal(target, 10);
196 | // 	// 			}
197 | // 	// 		},
198 | // 	// 		{
199 | // 	// 			it: 'should have the right name',
200 | // 	// 			self: 10,
201 | // 	// 			associatedObject: function (target, name, val) {
202 | // 	// 				assert.equal(name, '_foo');
203 | // 	// 			}
204 | // 	// 		}
205 | // 	// 	]);
206 | 
207 | // 	// 	describeCode('setter', '$(_foo) = 30', [
208 | // 	// 		{
209 | // 	// 			it: 'should have the right value',
210 | // 	// 			self: 10,
211 | // 	// 			associatedObject: function (target, name, val) {
212 | // 	// 				assert.equal(val, 30);
213 | // 	// 			}
214 | // 	// 		}
215 | // 	// 	]);
216 | // 	// });
217 | 
218 | // 	describe('$orig', function() {
219 | // 		describeCode('with default args', '$orig()', [
220 | // 			{
221 | // 				it: 'should have the right arguments',
222 | // 				arguments: ["a", "b", "c"],
223 | // 				orig: function (args) {
224 | // 					assert.equal(args.length, 3);
225 | // 					assert.equal(args[0], "a");
226 | // 					assert.equal(args[1], "b");
227 | // 					assert.equal(args[2], "c");
228 | // 				}
229 | // 			}
230 | // 		]);
231 | 
232 | // 		describeCode('with custom args', '$orig(a, b)', [
233 | // 			{
234 | // 				it: 'should have the right arguments',
235 | // 				a: "x",
236 | // 				b: "y",
237 | // 				orig: function (args) {
238 | // 					assert.equal(args.length, 2);
239 | // 					assert.equal(args[0], "x");
240 | // 					assert.equal(args[1], "y");
241 | // 				}
242 | // 			}
243 | // 		]);
244 | // 	});
245 | 	
246 | // 	// TODO: Add tests
247 | 	
248 | // 	describe('$class', function() {
249 | 		
250 | // 	});
251 | 
252 | // 	describe('$class hook', function() {
253 | // 		// remember to add tests for names with '.' in them (Swift), and unicode names too
254 | // 	});
255 | 
256 | // 	describe('Test file', function() {
257 | // 		it('should compile', function(done) {
258 | // 			fs.readFile('test/app.objs', function (err, file) {
259 | // 				if (err) done(err);
260 | // 				const transpiled = transpile(file);
261 | // 				console.log(transpiled);
262 | // 				done();
263 | // 			});
264 | // 		});
265 | // 	});
266 | 
267 | // });
268 | 


--------------------------------------------------------------------------------
/test/tests.objs:
--------------------------------------------------------------------------------
 1 | baz = [foo, bar];
 2 | [foo, [UIColor colorWithRed:1.0 green:1.0 blue:1.0 alpha:1.0]];
 3 | [foo,]
 4 | [foo];
 5 | [];
 6 | ["foo", "bar"][0];
 7 | 
 8 | NSLog([[NSString alloc] initWithString:"Hey"]);
 9 | 
10 | foo = [@("hey" + "!") stringByAppendingString:[[NSString alloc] initWithString:"what" + "?"]];
11 | 
12 | NSLog(@1);
13 | 
14 | %orig;
15 | %orig();
16 | %orig(foo + 1);
17 | %orig(foo + 1, bar);
18 | 
19 | @class MyClass : NSString
20 | 
21 | - (void)initWithString:(id)str {
22 | 	NSLog(str);
23 | }
24 | 
25 | @end
26 | 
27 | %hook MyClass
28 | 
29 | - (void)initWithName:(id)name {
30 | 	%orig(what);
31 | }
32 | 
33 | %end
34 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	entry: './src/index.js',
 3 | 	output: {
 4 | 		path: __dirname,
 5 | 		library: "OBJSTranspiler",
 6 | 		libraryTarget: 'var',
 7 | 		filename: 'ob.js'
 8 | 	},
 9 | 	resolve: {
10 | 		alias: {
11 | 			"fs": __dirname + "/src/fs.js"
12 | 		}
13 | 	},
14 | 	mode: 'production'
15 | };
16 | 


--------------------------------------------------------------------------------