johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/editline/editline.h

@@ -0,0 +1,135 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Simmule Turner and Rich Salz.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * Copyright 1992,1993 Simmule Turner and Rich Salz.  All rights reserved.
+ *
+ * This software is not subject to any license of the American Telephone
+ * and Telegraph Company or of the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on
+ * any computer system, and to alter it and redistribute it freely, subject
+ * to the following restrictions:
+ * 1. The authors are not responsible for the consequences of use of this
+ *    software, no matter how awful, even if they arise from flaws in it.
+ * 2. The origin of this software must not be misrepresented, either by
+ *    explicit claim or by omission.  Since few users ever read sources,
+ *    credits must appear in the documentation.
+ * 3. Altered versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.  Since few users
+ *    ever read sources, credits must appear in the documentation.
+ * 4. This notice may not be removed or altered.
+ */
+
+/*
+**  Internal header file for editline library.
+*/
+#include <stdio.h>
+#if	defined(HAVE_STDLIB)
+#include <stdlib.h>
+#include <string.h>
+#endif	/* defined(HAVE_STDLIB) */
+#if	defined(SYS_UNIX)
+#include "unix.h"
+#endif	/* defined(SYS_UNIX) */
+#if	defined(SYS_OS9)
+#include "os9.h"
+#endif	/* defined(SYS_OS9) */
+
+#if	!defined(SIZE_T)
+#define SIZE_T	unsigned int
+#endif	/* !defined(SIZE_T) */
+
+typedef unsigned char	CHAR;
+
+#if	defined(HIDE)
+#define STATIC	static
+#else
+#define STATIC	/* NULL */
+#endif	/* !defined(HIDE) */
+
+#if	!defined(CONST)
+#if	defined(__STDC__)
+#define CONST	const
+#else
+#define CONST
+#endif	/* defined(__STDC__) */
+#endif	/* !defined(CONST) */
+
+
+#define MEM_INC		64
+#define SCREEN_INC	256
+
+#define DISPOSE(p)	free((char *)(p))
+#define NEW(T, c)	\
+	((T *)malloc((unsigned int)(sizeof (T) * (c))))
+#define RENEW(p, T, c)	\
+	(p = (T *)realloc((char *)(p), (unsigned int)(sizeof (T) * (c))))
+#define COPYFROMTO(new, p, len)	\
+	(void)memcpy((char *)(new), (char *)(p), (int)(len))
+
+
+/*
+**  Variables and routines internal to this package.
+*/
+extern int	rl_eof;
+extern int	rl_erase;
+extern int	rl_intr;
+extern int	rl_kill;
+extern int	rl_quit;
+extern char	*rl_complete();
+extern int	rl_list_possib();
+extern void	rl_ttyset();
+extern void	rl_add_slash();
+
+#if	!defined(HAVE_STDLIB)
+extern char	*getenv();
+extern char	*malloc();
+extern char	*realloc();
+extern char	*memcpy();
+extern char	*strcat();
+extern char	*strchr();
+extern char	*strrchr();
+extern char	*strcpy();
+extern char	*strdup();
+extern int	strcmp();
+extern int	strlen();
+extern int	strncmp();
+#endif	/* !defined(HAVE_STDLIB) */
+

data/vendor/tracemonkey/editline/sysunix.c

@@ -0,0 +1,182 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Simmule Turner and Rich Salz.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * Copyright 1992,1993 Simmule Turner and Rich Salz.  All rights reserved.
+ *
+ * This software is not subject to any license of the American Telephone
+ * and Telegraph Company or of the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on
+ * any computer system, and to alter it and redistribute it freely, subject
+ * to the following restrictions:
+ * 1. The authors are not responsible for the consequences of use of this
+ *    software, no matter how awful, even if they arise from flaws in it.
+ * 2. The origin of this software must not be misrepresented, either by
+ *    explicit claim or by omission.  Since few users ever read sources,
+ *    credits must appear in the documentation.
+ * 3. Altered versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.  Since few users
+ *    ever read sources, credits must appear in the documentation.
+ * 4. This notice may not be removed or altered.
+ */
+
+
+/*
+**  Unix system-dependant routines for editline library.
+*/
+#include "editline.h"
+
+#if	defined(HAVE_TCGETATTR)
+#include <termios.h>
+
+void
+rl_ttyset(Reset)
+    int				Reset;
+{
+    static struct termios	old;
+    struct termios		new;
+
+    if (Reset == 0) {
+	(void)tcgetattr(0, &old);
+	rl_erase = old.c_cc[VERASE];
+	rl_kill = old.c_cc[VKILL];
+	rl_eof = old.c_cc[VEOF];
+	rl_intr = old.c_cc[VINTR];
+	rl_quit = old.c_cc[VQUIT];
+
+	new = old;
+	new.c_cc[VINTR] = -1;
+	new.c_cc[VQUIT] = -1;
+	new.c_lflag &= ~(ECHO | ICANON);
+	new.c_iflag &= ~(ISTRIP | INPCK);
+	new.c_cc[VMIN] = 1;
+	new.c_cc[VTIME] = 0;
+	(void)tcsetattr(0, TCSADRAIN, &new);
+    }
+    else
+	(void)tcsetattr(0, TCSADRAIN, &old);
+}
+
+#else
+#if	defined(HAVE_TERMIO)
+#include <termio.h>
+
+void
+rl_ttyset(Reset)
+    int				Reset;
+{
+    static struct termio	old;
+    struct termio		new;
+
+    if (Reset == 0) {
+	(void)ioctl(0, TCGETA, &old);
+	rl_erase = old.c_cc[VERASE];
+	rl_kill = old.c_cc[VKILL];
+	rl_eof = old.c_cc[VEOF];
+	rl_intr = old.c_cc[VINTR];
+	rl_quit = old.c_cc[VQUIT];
+
+	new = old;
+	new.c_cc[VINTR] = -1;
+	new.c_cc[VQUIT] = -1;
+	new.c_lflag &= ~(ECHO | ICANON);
+	new.c_iflag &= ~(ISTRIP | INPCK);
+	new.c_cc[VMIN] = 1;
+	new.c_cc[VTIME] = 0;
+	(void)ioctl(0, TCSETAW, &new);
+    }
+    else
+	(void)ioctl(0, TCSETAW, &old);
+}
+
+#else
+#include <sgtty.h>
+
+void
+rl_ttyset(Reset)
+    int				Reset;
+{
+    static struct sgttyb	old_sgttyb;
+    static struct tchars	old_tchars;
+    struct sgttyb		new_sgttyb;
+    struct tchars		new_tchars;
+
+    if (Reset == 0) {
+	(void)ioctl(0, TIOCGETP, &old_sgttyb);
+	rl_erase = old_sgttyb.sg_erase;
+	rl_kill = old_sgttyb.sg_kill;
+
+	(void)ioctl(0, TIOCGETC, &old_tchars);
+	rl_eof = old_tchars.t_eofc;
+	rl_intr = old_tchars.t_intrc;
+	rl_quit = old_tchars.t_quitc;
+
+	new_sgttyb = old_sgttyb;
+	new_sgttyb.sg_flags &= ~ECHO;
+	new_sgttyb.sg_flags |= RAW;
+#if	defined(PASS8)
+	new_sgttyb.sg_flags |= PASS8;
+#endif	/* defined(PASS8) */
+	(void)ioctl(0, TIOCSETP, &new_sgttyb);
+
+	new_tchars = old_tchars;
+	new_tchars.t_intrc = -1;
+	new_tchars.t_quitc = -1;
+	(void)ioctl(0, TIOCSETC, &new_tchars);
+    }
+    else {
+	(void)ioctl(0, TIOCSETP, &old_sgttyb);
+	(void)ioctl(0, TIOCSETC, &old_tchars);
+    }
+}
+#endif	/* defined(HAVE_TERMIO) */
+#endif	/* defined(HAVE_TCGETATTR) */
+
+void
+rl_add_slash(path, p)
+    char	*path;
+    char	*p;
+{
+    struct stat	Sb;
+
+    if (stat(path, &Sb) >= 0)
+	(void)strcat(p, S_ISDIR(Sb.st_mode) ? "/" : " ");
+}
+

data/vendor/tracemonkey/editline/unix.h

@@ -0,0 +1,82 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Simmule Turner and Rich Salz.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * Copyright 1992,1993 Simmule Turner and Rich Salz.  All rights reserved.
+ *
+ * This software is not subject to any license of the American Telephone
+ * and Telegraph Company or of the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on
+ * any computer system, and to alter it and redistribute it freely, subject
+ * to the following restrictions:
+ * 1. The authors are not responsible for the consequences of use of this
+ *    software, no matter how awful, even if they arise from flaws in it.
+ * 2. The origin of this software must not be misrepresented, either by
+ *    explicit claim or by omission.  Since few users ever read sources,
+ *    credits must appear in the documentation.
+ * 3. Altered versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.  Since few users
+ *    ever read sources, credits must appear in the documentation.
+ * 4. This notice may not be removed or altered.
+ */
+
+
+/*
+**  Editline system header file for Unix.
+*/
+
+#define CRLF		"\r\n"
+#define FORWARD		STATIC
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if	defined(USE_DIRENT)
+#include <dirent.h>
+typedef struct dirent	DIRENTRY;
+#else
+#include <sys/dir.h>
+typedef struct direct	DIRENTRY;
+#endif	/* defined(USE_DIRENT) */
+
+#if	!defined(S_ISDIR)
+#define S_ISDIR(m)		(((m) & S_IFMT) == S_IFDIR)
+#endif	/* !defined(S_ISDIR) */
+

data/vendor/tracemonkey/if.js

@@ -0,0 +1,13 @@
+function f() {
+	var q = 0;
+	for (var i = 0; i < 100; i++) {
+		if ((i & 1) == 0)
+			q++;
+		else
+			q--;
+	}	
+	print(q);
+}
+
+f();
+

data/vendor/tracemonkey/imacro_asm.js.in

@@ -0,0 +1,396 @@
+/* vim: set sw=4 ts=8 et tw=78 ft=javascript: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the TraceMonkey IMacro Assembler.
+ *
+ * The Initial Developer of the Original Code is
+ * Brendan Eich <brendan@mozilla.org>.
+ * Portions created by the Initial Developer are Copyright (C) 2008
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * An imacro (interpreter-macro) assembler in JS, with a light dusting of C
+ * pre-processor. We depend on the snarf function from the js shell, defined
+ * originally for the Narcissus metacircular evaluator, now unconditionally
+ * compiled into the shell.
+ *
+ * Filename suffix conventions, used by Makefile.in rules:
+ *   .js.in     C-pre-processed JS source
+ *   .jsasm     SpiderMonkey JS assembly source, which could be input to other
+ *              assemblers than imacro_asm.js, hence the generic suffix!
+ *   .c.out     C source output by imacro_asm.js
+ */
+
+#define ASSERT(cond)    _ASSERT(cond, #cond)
+
+function _ASSERT(cond, message) {
+    if (!cond)
+        throw new Error("Assertion failed: " + message);
+}
+
+const js_arguments_str  = "arguments";
+const js_new_str        = "new";
+const js_typeof_str     = "typeof";
+const js_void_str       = "void";
+const js_null_str       = "null";
+const js_this_str       = "this";
+const js_false_str      = "false";
+const js_true_str       = "true";
+const js_throw_str      = "throw";
+const js_in_str         = "in";
+const js_instanceof_str = "instanceof";
+const js_getter_str     = "getter";
+const js_setter_str     = "setter";
+
+#define OPDEF(op,val,name,token,length,nuses,ndefs,prec,format)               \
+    {jsop: #op, opcode: val, opname: name, opsrc: token, oplen: length,       \
+     pops: nuses, pushes: ndefs, precedence: prec, flags: #format},
+
+const NULL = null;
+
+const opinfo = [
+#include "jsopcode.tbl"
+];
+
+const opname2info = {};
+const jsop2opcode = {};
+
+for (let i = 0; i < opinfo.length; i++) {
+    let info = opinfo[i];
+    ASSERT(info.opcode == i);
+    opname2info[info.opname] = info;
+    jsop2opcode[info.jsop] = info.opcode;
+}
+
+function format_offset(n, w) {
+    let s = n.toString();
+    while (s.length < w)
+        s = ' ' + s;
+    return s;
+}
+
+function immediate(op) {
+    let info = op.info;
+    let imm1Expr = /^\(/.test(op.imm1);
+    if (info.flags.indexOf("JOF_ATOM") >= 0) {
+        if (/^(?:void|object|function|string|number|boolean)$/.test(op.imm1))
+            return "0, COMMON_TYPE_ATOM_INDEX(JSTYPE_" + op.imm1.toUpperCase() + ")";
+        return "0, COMMON_ATOM_INDEX(" + op.imm1 + ")";
+    }
+    if (info.flags.indexOf("JOF_JUMP") >= 0) {
+        ASSERT(!imm1Expr);
+        return ((op.target >> 8) & 0xff) + ", " + (op.target & 0xff);
+    }
+    if (info.flags.indexOf("JOF_UINT8") >= 0 ||
+        info.flags.indexOf("JOF_INT8") >= 0) {
+        if (imm1Expr)
+            return op.imm1;
+        if (isNaN(Number(op.imm1)) || Number(op.imm1) != parseInt(op.imm1))
+            throw new Error("invalid 8-bit operand: " + op.imm1);
+        return (op.imm1 & 0xff);
+    }
+    if (info.flags.indexOf("JOF_UINT16") >= 0) {
+        if (imm1Expr)
+            return '(_ & 0xff00) >> 8, (_ & 0xff)'.replace(/_/g, op.imm1);
+        return ((op.imm1 & 0xff00) >> 8) + ", " + (op.imm1 & 0xff);
+    }
+    throw new Error(info.jsop + " format not yet implemented");
+}
+
+function simulate_cfg(imacro, depth, i) {
+    while (i < imacro.code.length) {
+        let op = imacro.code[i];
+        depth -= (op.info.pops < 0) ? 2 + Number(op.imm1) : op.info.pops;
+        depth += op.info.pushes;
+
+        if (imacro.depths.hasOwnProperty(i) && imacro.depths[i] != depth)
+            throw Error("Mismatched depth at " + imacro.filename + ":" + op.line);
+
+        /*
+         * Underflowing depth isn't necessarily fatal; most of the imacros
+         * assume they are called with N>0 args so some assume it's ok to go
+         * to some depth <N. We simulate starting from 0, as we've no idea
+         * what else to do.
+         *
+         * if (depth < 0)
+         *   throw Error("Negative static-stack depth at " + imacro.filename + ":" + op.line);
+         */
+        if (depth > imacro.maxdepth)
+            imacro.maxdepth = depth;
+        imacro.depths[i] = depth;
+
+        if (op.hasOwnProperty("target_index")) {
+            if (op.target_index <= i)
+                throw Error("Backward jump at " + imacro.filename + ":" + op.line);
+
+            simulate_cfg(imacro, depth, op.target_index);
+
+            if (op.info.opname == "goto" || op.info.opname == "gotox")
+                return;
+        }
+        ++i;
+    }
+}
+
+/*
+ * Syntax (spaces are significant only to delimit tokens):
+ *
+ *   Assembly   ::= (Directive? '\n')*
+ *   Directive  ::= (name ':')? Operation
+ *   Operation  ::= opname Operands?
+ *   Operands   ::= Operand (',' Operand)*
+ *   Operand    ::= name | number | '(' Expr ')'
+ *   Expr       ::= a constant-expression in the C++ language
+ *                  containing no parentheses
+ *
+ * We simplify given line structure and the maximum of one immediate operand,
+ * by parsing using split and regexps.  For ease of parsing, parentheses are
+ * banned in an Expr for now, even in quotes or a C++ comment.
+ *
+ * Pseudo-ops start with . and include .igroup and .imacro, terminated by .end.
+ * .imacro must nest in .igroup, neither nests in itself. See imacros.jsasm for
+ * examples.
+ */
+const line_regexp_parts = [
+    "^(?:(\\w+):)?",                    // optional label at start of line
+    "\\s*(\\.?\\w+)",                   // optional spaces, (pseudo-)opcode
+    "(?:\\s+(\\w+|\\([^)]*\\)))?",      // optional first immediate operand
+    "(?:\\s+([\\w-]+|\\([^)]*\\)))?",   // optional second immediate operand
+    "(?:\\s*(?:#.*))?$"                 // optional spaces and comment
+];
+
+const line_regexp = new RegExp(line_regexp_parts.join(""));
+
+function assemble(filename) {
+    let igroup = null, imacro = null;
+    let opcode2extra = [];
+    let igroups = [];
+
+    print("/* GENERATED BY imacro_asm.js -- DO NOT EDIT!!! */");
+
+    let s = snarf(filename);
+    let a = s.split('\n');
+    for (let i = 0; i < a.length; i++) {
+        if (/^\s*(?:#.*)?$/.test(a[i]))
+            continue;
+        let m = line_regexp.exec(a[i]);
+        if (!m)
+            throw new Error(a[i]);
+
+        let [, label, opname, imm1, imm2] = m;
+
+        if (opname[0] == '.') {
+            if (label)
+                throw new Error("invalid label " + label + " before " + opname);
+
+            switch (opname) {
+              case ".igroup":
+                if (!imm1)
+                    throw new Error("missing .igroup name");
+                if (igroup)
+                    throw new Error("nested .igroup " + imm1);
+                let oprange = imm2.match(/^(\w+)(?:-(\w+))?$/);
+                if (!oprange)
+                    throw new Error("invalid igroup operator range " + imm2);
+                let firstop = jsop2opcode[oprange[1]];
+                igroup = {
+                    name:    imm1,
+                    firstop: firstop,
+                    lastop:  oprange[2] ? jsop2opcode[oprange[2]] : firstop,
+                    imacros: []
+                };
+                break;
+
+              case ".imacro":
+                if (!igroup)
+                    throw new Error(".imacro outside of .igroup");
+                if (!imm1)
+                    throw new Error("missing .imacro name");
+                if (imacro)
+                    throw new Error("nested .imacro " + imm1);
+                imacro = {
+                    name:      imm1,
+                    offset:    0,
+                    code:      [],
+                    labeldefs: {},
+                    labeldef_indexes: {},
+                    labelrefs: {},
+                    filename: filename,
+                    depths: {}
+                };
+                break;
+
+              case ".end":
+                if (!imacro) {
+                    if (!igroup)
+                        throw new Error(".end without prior .igroup or .imacro");
+                    if (imm1 && (imm1 != igroup.name || imm2))
+                        throw new Error(".igroup/.end name mismatch");
+
+                    let maxdepth = 0;
+
+                    print("static struct {");
+                    for (let j = 0; j < igroup.imacros.length; j++) {
+                        imacro = igroup.imacros[j];
+                        print("    jsbytecode " + imacro.name + "[" + imacro.offset + "];");
+                    }
+                    print("} " + igroup.name + "_imacros = {");
+
+                    for (let j = 0; j < igroup.imacros.length; j++) {
+                        let depth = 0;
+
+                        imacro = igroup.imacros[j];
+                        print("    {");
+                        for (let k = 0; k < imacro.code.length; k++) {
+                            let op = imacro.code[k];
+
+                            print("/*" + format_offset(op.offset,2) + "*/  " + op.info.jsop +
+                                  (op.imm1 ? ", " + immediate(op) : "") + ",");
+
+                        }
+
+                        imacro.maxdepth = 0;
+                        simulate_cfg(imacro, 0, 0);
+                        if (imacro.maxdepth > maxdepth)
+                            maxdepth = imacro.maxdepth;
+
+                        print("    },");
+                    }
+
+                    print("};");
+
+                    let opcode = igroup.firstop;
+                    let oplast = igroup.lastop;
+                    do {
+                        opcode2extra[opcode] = maxdepth;
+                    } while (opcode++ != oplast);
+                    igroups.push(igroup);
+                    igroup = null;
+                } else {
+                    ASSERT(igroup);
+
+                    if (imm1 && imm1 != imacro.name)
+                        throw new Error(".imacro/.end name mismatch");
+
+                    // Backpatch the forward references to labels that must now be defined.
+                    for (label in imacro.labelrefs) {
+                        if (!imacro.labelrefs.hasOwnProperty(label))
+                            continue;
+                        if (!imacro.labeldefs.hasOwnProperty(label))
+                            throw new Error("label " + label + " used but not defined");
+                        let link = imacro.labelrefs[label];
+                        ASSERT(link >= 0);
+                        for (;;) {
+                            let op = imacro.code[link];
+                            ASSERT(op);
+                            ASSERT(op.hasOwnProperty('target'));
+                            let next = op.target;
+                            op.target = imacro.labeldefs[label] - op.offset;
+                            op.target_index = imacro.labeldef_indexes[label];
+                            if (next < 0)
+                                break;
+                            link = next;
+                        }
+                    }
+
+                    igroup.imacros.push(imacro);
+                }
+                imacro = null;
+                break;
+
+              default:
+                throw new Error("unknown pseudo-op " + opname);
+            }
+            continue;
+        }
+
+        if (!opname2info.hasOwnProperty(opname))
+            throw new Error("unknown opcode " + opname + (label ? " (label " + label + ")" : ""));
+
+        let info = opname2info[opname];
+        if (info.oplen == -1)
+            throw new Error("unimplemented opcode " + opname);
+
+        if (!imacro)
+            throw new Error("opcode " + opname + " outside of .imacro");
+
+        if (label) {
+            imacro.labeldefs[label] = imacro.offset;
+            imacro.labeldef_indexes[label] = imacro.code.length;
+        }
+
+        let op = {offset: imacro.offset, info: info, imm1: imm1, imm2: imm2, line:(i+1) };
+        if (info.flags.indexOf("JOF_JUMP") >= 0) {
+            if (imacro.labeldefs.hasOwnProperty(imm1)) {
+                // Backward reference can be resolved right away, no backpatching needed.
+                op.target = imacro.labeldefs[imm1] - op.offset;
+                op.target_index = imacro.labeldef_indexes[imm1];
+            } else {
+                // Link op into the .target-linked backpatch chain at labelrefs[imm1].
+                // The linked list terminates with a -1 sentinel.
+                op.target = imacro.labelrefs.hasOwnProperty(imm1) ? imacro.labelrefs[imm1] : -1;
+                imacro.labelrefs[imm1] = imacro.code.length;
+            }
+        }
+
+        imacro.code.push(op);
+        imacro.offset += info.oplen;
+    }
+
+    print("uint8 js_opcode2extra[JSOP_LIMIT] = {");
+    for (let i = 0; i < opinfo.length; i++) {
+        print("    " + ((i in opcode2extra) ? opcode2extra[i] : "0") +
+              ",  /* " + opinfo[i].jsop + " */");
+    }
+    print("};");
+
+    print("#define JSOP_IS_IMACOP(x) (0 \\");
+    for (let i in opcode2extra)
+        print(" || x == " + opinfo[i].jsop + " \\");
+    print(")");
+
+    print("jsbytecode*\njs_GetImacroStart(jsbytecode* pc) {");
+    for each (let g in igroups) {
+        for each (let m in g.imacros) {
+            let start = g.name + "_imacros." + m.name;
+            print("    if (size_t(pc - " + start + ") < " + m.offset + ") return " + start + ";");
+        }
+    }
+    print("    return NULL;");
+    print("}");
+}
+
+for (let i = 0; i < arguments.length; i++) {
+    try {
+        assemble(arguments[i]);
+    } catch (e) {
+        print(e.name + ": " + e.message + "\n" + e.stack);
+    }
+}