struct jffs2_raw_inode *find_raw_inode(char *o, size_t size, uint32_t ino)
{
/* aligned! */
union jffs2_node_union *n;
union jffs2_node_union *e = (union jffs2_node_union *) (o + size);
union jffs2_node_union *lr; /* last block position */
union jffs2_node_union *mp = NULL; /* minimum position */
uint32_t vmin, vmint, vmaxt, vmax, vcur, v;
vmin = 0; /* next to read */
vmax = ~((uint32_t) 0); /* last to read */
vmint = ~((uint32_t) 0);
vmaxt = 0; /* found maximum */
vcur = 0; /* XXX what is smallest version number used? */
/* too low version number can easily result excess log rereading */
n = (union jffs2_node_union *) o;
lr = n;
do {
while (n < e && je16_to_cpu(n->u.magic) != JFFS2_MAGIC_BITMASK)
ADD_BYTES(n, 4);
if (n < e && je16_to_cpu(n->u.magic) == JFFS2_MAGIC_BITMASK) {
if (je16_to_cpu(n->u.nodetype) == JFFS2_NODETYPE_INODE &&
je32_to_cpu(n->i.ino) == ino && (v = je32_to_cpu(n->i.version)) > vcur) {
/* XXX crc check */
if (vmaxt < v)
vmaxt = v;
if (vmint > v) {
vmint = v;
mp = n;
}
if (v == (vcur + 1))
return (&(n->i));
}
ADD_BYTES(n, ((je32_to_cpu(n->u.totlen) + 3) & ~3));
} else
n = (union jffs2_node_union *) o; /* we're at the end, rewind to the beginning */
if (lr == n) { /* whole loop since last read */
vmax = vmaxt;
vmin = vmint;
vmint = ~((uint32_t) 0);
if (vcur < vmax && vcur < vmin)
return (&(mp->i));
}
} while (vcur < vmax);
return NULL;
}
/**
* lupb_map_new
*
* Handles:
* new_map = upb.Map(key_type, value_type)
*/
static int lupb_map_new(lua_State *L) {
lupb_map *lmap;
upb_fieldtype_t key_type = lupb_checkfieldtype(L, 1);
upb_fieldtype_t value_type;
const lupb_msgclass *value_lmsgclass = NULL;
if (lua_type(L, 2) == LUA_TNUMBER) {
value_type = lupb_checkfieldtype(L, 2);
} else {
value_type = UPB_TYPE_MESSAGE;
}
lmap = lupb_newuserdata(
L, sizeof(*lmap) + upb_map_sizeof(key_type, value_type), LUPB_MAP);
lmap->map = ADD_BYTES(lmap, sizeof(*lmap));
if (value_type == UPB_TYPE_MESSAGE) {
value_lmsgclass = lupb_msgclass_check(L, 2);
lupb_uservalseti(L, -1, MAP_MSGCLASS_INDEX, 2); /* GC-root lmsgclass. */
}
lmap->value_lmsgclass = value_lmsgclass;
upb_map_init(lmap->map, key_type, value_type, lupb_alloc_get(L));
return 1;
}
struct jffs2_raw_dirent *resolvedirent(char *o, size_t size,
uint32_t ino, uint32_t pino,
char *name, uint8_t nsize)
{
/* aligned! */
union jffs2_node_union *n;
union jffs2_node_union *e = (union jffs2_node_union *) (o + size);
struct jffs2_raw_dirent *dd = NULL;
uint32_t vmax, v;
if (!pino && ino <= 1)
return dd;
vmax = 0;
n = (union jffs2_node_union *) o;
do {
while (n < e && je16_to_cpu(n->u.magic) != JFFS2_MAGIC_BITMASK)
ADD_BYTES(n, 4);
if (n < e && je16_to_cpu(n->u.magic) == JFFS2_MAGIC_BITMASK) {
if (je16_to_cpu(n->u.nodetype) == JFFS2_NODETYPE_DIRENT &&
(!ino || je32_to_cpu(n->d.ino) == ino) &&
(v = je32_to_cpu(n->d.version)) > vmax &&
(!pino || (je32_to_cpu(n->d.pino) == pino &&
nsize == n->d.nsize &&
!memcmp(name, n->d.name, nsize)))) {
/* XXX crc check */
if (vmax < v) {
vmax = v;
dd = &(n->d);
}
}
ADD_BYTES(n, ((je32_to_cpu(n->u.totlen) + 3) & ~3));
} else
return dd;
} while (1);
}
/**
* lupb_msg_pushnew
*
* Handles:
* new_msg = MessageClass()
*/
static int lupb_msg_pushnew(lua_State *L, int narg) {
const lupb_msgclass *lmsgclass = lupb_msgclass_check(L, narg);
size_t size = sizeof(lupb_msg) + upb_msg_sizeof(lmsgclass->layout);
lupb_msg *lmsg = lupb_newuserdata(L, size, LUPB_MSG);
lmsg->lmsgclass = lmsgclass;
lmsg->msg = ADD_BYTES(lmsg, sizeof(*lmsg));
upb_msg_init(lmsg->msg, lmsgclass->layout, lupb_alloc_get(L));
lupb_uservalseti(L, -1, LUPB_MSG_MSGCLASSINDEX, narg);
return 1;
}
static int lupb_array_new(lua_State *L) {
lupb_array *larray;
upb_fieldtype_t type;
const lupb_msgclass *lmsgclass = NULL;
if (lua_type(L, 1) == LUA_TNUMBER) {
type = lupb_checkfieldtype(L, 1);
} else {
type = UPB_TYPE_MESSAGE;
lmsgclass = lupb_msgclass_check(L, 1);
lupb_uservalseti(L, -1, ARRAY_MSGCLASS_INDEX, 1); /* GC-root lmsgclass. */
}
larray =
lupb_newuserdata(L, sizeof(*larray) + upb_array_sizeof(type), LUPB_ARRAY);
larray->lmsgclass = lmsgclass;
larray->arr = ADD_BYTES(larray, sizeof(*larray));
upb_array_init(larray->arr, type, lupb_alloc_get(L));
return 1;
}
DWORD CompStr::Store(const LogCompStr *log) {
const DWORD total = log->GetTotalSize();
BYTE *pb = GetBytes();
dwSize = total;
dwCursorPos = log->dwCursorPos;
dwDeltaStart = log->dwDeltaStart;
pb += sizeof(COMPOSITIONSTRING);
#define ADD_BYTES(member) \
if (log->member.size()) { \
memcpy(pb, &log->member[0], log->member.size() * sizeof(BYTE)); \
pb += log->member.size() * sizeof(BYTE); \
}
#define ADD_DWORDS(member) \
if (log->member.size()) { \
memcpy(pb, &log->member[0], log->member.size() * sizeof(DWORD)); \
pb += log->member.size() * sizeof(DWORD); \
}
#define ADD_STRING(member) \
if (log->member.size()) { \
memcpy(pb, &log->member[0], log->member.size() * sizeof(WCHAR)); \
pb += log->member.size() * sizeof(WCHAR); \
}
dwCompReadAttrOffset = DWORD(pb - GetBytes());
dwCompReadAttrLen = log->comp_read_attr.size() * sizeof(BYTE);
ADD_BYTES(comp_read_attr);
dwCompReadClauseOffset = DWORD(pb - GetBytes());
dwCompReadClauseLen = log->comp_read_clause.size() * sizeof(DWORD);
ADD_DWORDS(comp_read_clause);
dwCompReadStrOffset = DWORD(pb - GetBytes());
dwCompReadStrLen = log->comp_read_str.size();
ADD_STRING(comp_read_str);
dwCompAttrOffset = DWORD(pb - GetBytes());
dwCompAttrLen = log->comp_attr.size() * sizeof(BYTE);
ADD_BYTES(comp_attr);
dwCompClauseOffset = DWORD(pb - GetBytes());
dwCompClauseLen = log->comp_clause.size() * sizeof(DWORD);
ADD_DWORDS(comp_clause);
dwCompStrOffset = DWORD(pb - GetBytes());
dwCompStrLen = log->comp_str.size();
ADD_STRING(comp_str);
dwResultReadClauseOffset = DWORD(pb - GetBytes());
dwResultReadClauseLen = log->result_read_clause.size() * sizeof(DWORD);
ADD_DWORDS(result_read_clause);
dwResultReadStrOffset = DWORD(pb - GetBytes());
dwResultReadStrLen = log->result_read_str.size();
ADD_STRING(result_read_str);
dwResultClauseOffset = DWORD(pb - GetBytes());
dwResultClauseLen = log->result_clause.size() * sizeof(DWORD);
ADD_DWORDS(result_clause);
dwResultStrOffset = DWORD(pb - GetBytes());
dwResultStrLen = log->result_str.size();
ADD_STRING(result_str);
COMPSTREXTRA *pExtra = (COMPSTREXTRA *)pb;
dwPrivateSize = log->extra.GetTotalSize();
dwPrivateOffset = DWORD(pb - GetBytes());
pb += pExtra->Store(&log->extra);
#undef ADD_BYTES
#undef ADD_DWORDS
#undef ADD_STRING
assert(DWORD(pb - GetBytes()) == total);
return DWORD(pb - GetBytes());
} // CompStr::Store
static void
disassemble(Program * prog, Printer p, void *data)
{
Stream *s = new_stream(100);
Stream *insn = new_stream(50);
int i, l;
unsigned pc;
Bytecodes bc;
const char *ptr;
const char **names = prog->var_names;
unsigned tmp, num_names = prog->num_var_names;
# define NAMES(i) (tmp = i, \
tmp < num_names ? names[tmp] \
: "*** Unknown variable ***")
Var *literals = prog->literals;
initialize_tables();
print = p;
print_data = data;
stream_printf(s, "Language version number: %d", (int) prog->version);
output(s);
stream_printf(s, "First line number: %d", prog->first_lineno);
output(s);
for (i = -1; i < 0 || i < prog->fork_vectors_size; i++) {
output(s);
if (i == -1) {
stream_printf(s, "Main code vector:");
output(s);
stream_printf(s, "=================");
output(s);
bc = prog->main_vector;
} else {
stream_printf(s, "Forked code vector %d:", i);
l = stream_length(s);
output(s);
while (l--)
stream_add_char(s, '=');
output(s);
bc = prog->fork_vectors[i];
}
stream_printf(s, "[Bytes for labels = %d, literals = %d, ",
bc.numbytes_label, bc.numbytes_literal);
stream_printf(s, "forks = %d, variables = %d, stack refs = %d]",
bc.numbytes_fork, bc.numbytes_var_name,
bc.numbytes_stack);
output(s);
stream_printf(s, "[Maximum stack size = %d]", bc.max_stack);
output(s);
max_bytes_width = 5;
for (pc = 0; pc < bc.size;) {
Byte b;
unsigned arg;
# define ADD_BYTES(n) (arg = add_bytes(s, bc.vector, pc, n), \
pc += n, \
arg)
unsigned a1, a2;
new_insn(s, pc);
b = add_bytes(s, bc.vector, pc++, 1);
if (b != OP_EXTENDED)
stream_add_string(insn, COUNT_TICK(b) ? " * " : " ");
if (IS_OPTIM_NUM_OPCODE(b))
stream_printf(insn, "NUM %d", OPCODE_TO_OPTIM_NUM(b));
#ifdef BYTECODE_REDUCE_REF
else if (IS_PUSH_CLEAR_n(b))
stream_printf(insn, "PUSH_CLEAR %s", NAMES(PUSH_CLEAR_n_INDEX(b)));
#endif /* BYTECODE_REDUCE_REF */
else if (IS_PUSH_n(b))
stream_printf(insn, "PUSH %s", NAMES(PUSH_n_INDEX(b)));
else if (IS_PUT_n(b))
stream_printf(insn, "PUT %s", NAMES(PUT_n_INDEX(b)));
else if (b == OP_EXTENDED) {
b = ADD_BYTES(1);
stream_add_string(insn, COUNT_EOP_TICK(b) ? " * " : " ");
stream_add_string(insn, ext_mnemonics[b]);
switch ((Extended_Opcode) b) {
case EOP_WHILE_ID:
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s %d", NAMES(a1), a2);
break;
case EOP_EXIT_ID:
stream_printf(insn, " %s",
NAMES(ADD_BYTES(bc.numbytes_var_name)));
/* fall thru */
case EOP_EXIT:
a1 = ADD_BYTES(bc.numbytes_stack);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %d %d", a1, a2);
break;
case EOP_PUSH_LABEL:
case EOP_END_CATCH:
case EOP_END_EXCEPT:
case EOP_TRY_FINALLY:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_label));
break;
case EOP_TRY_EXCEPT:
stream_printf(insn, " %d", ADD_BYTES(1));
break;
case EOP_LENGTH:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_stack));
break;
case EOP_SCATTER:
{
int i, nargs = ADD_BYTES(1);
a1 = ADD_BYTES(1);
a2 = ADD_BYTES(1);
stream_printf(insn, " %d/%d/%d:", nargs, a1, a2);
for (i = 0; i < nargs; i++) {
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s/%d", NAMES(a1), a2);
}
stream_printf(insn, " %d",
ADD_BYTES(bc.numbytes_label));
}
break;
default:
break;
}
} else {
stream_add_string(insn, mnemonics[b]);
switch ((Opcode) b) {
case OP_IF:
case OP_IF_QUES:
case OP_EIF:
case OP_AND:
case OP_OR:
case OP_JUMP:
case OP_WHILE:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_label));
break;
case OP_FORK:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_fork));
break;
case OP_FORK_WITH_ID:
a1 = ADD_BYTES(bc.numbytes_fork);
a2 = ADD_BYTES(bc.numbytes_var_name);
stream_printf(insn, " %d %s", a1, NAMES(a2));
break;
case OP_FOR_LIST:
case OP_FOR_RANGE:
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s %d", NAMES(a1), a2);
break;
case OP_G_PUSH:
#ifdef BYTECODE_REDUCE_REF
case OP_G_PUSH_CLEAR:
#endif /* BYTECODE_REDUCE_REF */
case OP_G_PUT:
stream_printf(insn, " %s",
NAMES(ADD_BYTES(bc.numbytes_var_name)));
break;
case OP_IMM:
{
Var v;
v = literals[ADD_BYTES(bc.numbytes_literal)];
switch (v.type) {
case TYPE_OBJ:
stream_printf(insn, " #%d", v.v.obj);
break;
case TYPE_INT:
stream_printf(insn, " %d", v.v.num);
break;
case TYPE_STR:
stream_add_string(insn, " \"");
for (ptr = v.v.str; *ptr; ptr++) {
if (*ptr == '"' || *ptr == '\\')
stream_add_char(insn, '\\');
stream_add_char(insn, *ptr);
}
stream_add_char(insn, '"');
break;
case TYPE_ERR:
stream_printf(insn, " %s", error_name(v.v.err));
break;
default:
stream_printf(insn, " <literal type = %d>",
v.type);
break;
}
}
break;
case OP_BI_FUNC_CALL:
stream_printf(insn, " %s", name_func_by_num(ADD_BYTES(1)));
default:
break;
}
}
finish_insn(s, insn);
}
}
free_stream(s);
free_stream(insn);
}
