Пример #1
0
int main( void )
{
    int const xs[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    printf( "Testing subset slice...\n" );
    int const ws[] = { SLICE( xs, 3, 4 ) };
    ASSERT( NELEM( ws ) == 4,
            ws[ 0 ] == xs[ 3 ],
            ws[ 1 ] == xs[ 4 ],
            ws[ 2 ] == xs[ 5 ],
            ws[ 3 ] == xs[ 6 ] );
    ( void ) ws;

    printf( "Testing total slice...\n" );
    int const ys[] = { SLICE( xs, 0, 6 ) };
    ASSERT( NELEM( ys ) == 6,
            ys[ 0 ] == xs[ 0 ],
            ys[ 1 ] == xs[ 1 ],
            ys[ 2 ] == xs[ 2 ],
            ys[ 3 ] == xs[ 3 ],
            ys[ 4 ] == xs[ 4 ],
            ys[ 5 ] == xs[ 5 ] );
    ( void ) ys;

    printf( "Testing empty slice...\n" );
    int const zs[] = { 0, SLICE( xs, 2, 0 ) };
    ASSERT( NELEM( zs ) == 1 );
    ( void ) zs;

    printf( "SLICE() tests passed.\n" );
}
Пример #2
0
unsigned bitmap_ffs(const uint32_t *bitmap, unsigned from, unsigned size) {
  unsigned index_last = BITMAP_WORD(size - 1);
  unsigned from_word = BITMAP_WORD(from);

  if (from_word == index_last) {
    uint32_t mask = SLICE(~0u, (size - 1) % BITS_PER_WORD, from % BITS_PER_WORD)
        << (from % BITS_PER_WORD);
    uint32_t word = bitmap[from_word] & mask;
    if (word != 0)
      return from_word * BITS_PER_WORD + bit_ffs(word) - 1;
    else
      return size;
  }

  if (bitmap[from_word] != 0) {
    uint32_t first_mask = SLICE(~0u, BITS_PER_WORD - 1, from % BITS_PER_WORD)
        << (from % BITS_PER_WORD);
    uint32_t first_word = bitmap[from_word] & first_mask;
    if (first_word != 0)
      return from_word * BITS_PER_WORD + bit_ffs(first_word) - 1;
  }

  for (unsigned w = from_word + 1; w < index_last; ++w) {
    if (bitmap[w] != 0)
      return w * BITS_PER_WORD + bit_ffs(bitmap[w]) - 1;
  }

  if (index_last != from_word) {
    uint32_t last = bitmap[index_last] & BITMAP_MASK_LAST(size);
    if (last != 0)
      return index_last * BITS_PER_WORD + bit_ffs(last) - 1;
  }

  return size;
}
Пример #3
0
// Find the last non-zero word, last bit set in word has index
// [bit_fls(word)].
unsigned bitmap_fls(const uint32_t *bitmap, unsigned from, unsigned size) {
  unsigned from_word = BITMAP_WORD(from);
  unsigned index_last = BITMAP_WORD(size - 1);
  uint32_t last = bitmap[index_last] & BITMAP_MASK_LAST(size);

  if (index_last == from_word) {
    uint32_t mask = SLICE(~0u, (size - 1) % BITS_PER_WORD, from % BITS_PER_WORD)
        << (from % BITS_PER_WORD);
    last = last & mask;
  }

  if (last != 0)
    return index_last * BITS_PER_WORD + bit_fls(last);

  for (int w = index_last - 1; w >= (int)from_word; --w) {
    if (bitmap[w] != 0)
      return w * BITS_PER_WORD + bit_fls(bitmap[w]);
  }

  if (index_last != from_word && bitmap[from_word] != 0) {
    uint32_t first_mask = SLICE(~0u, BITS_PER_WORD - 1, from % BITS_PER_WORD)
        << (from % BITS_PER_WORD);
    uint32_t first_word = bitmap[from_word] & first_mask;
    if (first_word != 0)
      return from_word * BITS_PER_WORD + bit_fls(first_word);
  }

  return size;
}
Пример #4
0
void fn0C00_0100(word16 cx, Eq_13 Eq_14::*bx, byte Eq_21::*di, Eq_14 * ds)
{
    bios_video_set_mode(0x13);
    __outw(0x03D4, DPB(ax, 0x20, 8, 8));
    ptr32 es_ax_12 = Mem0[ds:bx + 0x0000:segptr32];
    Eq_19 al_13 = (byte) es_ax_12;
    Eq_21 * es_15 = SLICE(es_ax_12, selector, 16);
    do
    {
        __outb(0x03C9, al_13);
        al_13 = al_13 + 0x95 + C;
        C = cond(al_13);
        if (al_13 != 0x00)
            continue;
        do
        {
            es_15->*di = (byte) cx_57 ^ SLICE(cx_57, byte, 8);
            C = false;
            di = di + 1;
            cx = cx_57 - 0x0001;
            word16 cx_57 = cx;
        } while (cx != 0x0000);
        word16 ax_50 = DPB(cx_57, __inb(0x60), 0, 8);
        al_13 = (byte) (ax_50 - 0x0001);
    } while (ax_50 != 0x0001);
    return;
}
Пример #5
0
void fn0C00_0100(Eq_36 * ds)
{
	bios_video_set_mode(0x13);
	__outb(0x03C8, 0x00);
	byte al_11 = 0x00;
	do
	{
		__outb(0x03C9, al_11);
		al_11 = al_11 + 0x01;
	} while (al_11 != 0x00);
	byte ah_19 = SLICE(cs, byte, 8);
	Eq_23 * ax_21 = DPB(cs, ah_19 + 0x10, 8, 8);
	Eq_23 * ax_24 = DPB(cs, ah_19 + 0x20, 8, 8);
	Eq_31 Eq_23::*bx_30 = Eq_23::a0000;
	do
	{
		rLoc2 = sin(rLoc2) * (real64) ds->ptr01C6;
		(ax_24->*bx_30).w0000 = (int16) rLoc2;
		(ax_21->*bx_30).w0000 = 0x0000;
		word16 bx_48 = &bx_30->w0000;
		bx_30 = bx_48 + 0x0001;
	} while (bx_48 != 0x0001);
	Eq_56 Eq_36::*di_55 = &Eq_36::t010A;
	do
	{
		word16 si_66 = (ds->*di_55).w0000;
		byte Eq_23::*bx_67 = Eq_23::a0000;
		int8 bl_68 = 0x00;
		int8 bh_69 = 0x00;
		do
		{
			if (bh_69 *s bh_69 + bl_68 *s bl_68 <=u 0x09C3)
				bx_67[si_66] = 0xC9;
			bx_67 = bx_67 + 1;
			bl_68 = (byte) bx_67;
			bh_69 = SLICE(bx_67, byte, 8);
		} while (bx_67 != Eq_23::a0000);
		word16 di_91 = di_55 - 0x0001;
		di_55 = di_91 - 0x0001;
	} while (di_91 != 0xFF01);
	do
	{
		byte Z_95 = fn0C00_0171(0xA000, ds, ax_21, ax_24);
		byte al_96;
		bios_kbd_check_keystroke(out al_96);
	} while (Z_95);
	bios_video_set_mode(0x03);
	return;
}
Пример #6
0
static int slice_enumerate(Manager *m) {
        Unit *u;
        int r;

        assert(m);

        u = manager_get_unit(m, SPECIAL_ROOT_SLICE);
        if (!u) {
                u = unit_new(m, sizeof(Slice));
                if (!u)
                        return log_oom();

                r = unit_add_name(u, SPECIAL_ROOT_SLICE);
                if (r < 0) {
                        unit_free(u);
                        return log_error_errno(r, "Failed to add -.slice name");
                }
        }

        u->default_dependencies = false;
        u->no_gc = true;
        SLICE(u)->deserialized_state = SLICE_ACTIVE;

        if (!u->description)
                u->description = strdup("Root Slice");
        if (!u->documentation)
                (void) strv_extend(&u->documentation, "man:systemd.special(7)");

        unit_add_to_load_queue(u);
        unit_add_to_dbus_queue(u);

        return 0;
}
Пример #7
0
static void slice_done(Unit *u) {
        Slice *s = SLICE(u);

        assert(u);

        cgroup_context_done(&s->cgroup_context);
}
Пример #8
0
static int slice_load(Unit *u) {
        Slice *s = SLICE(u);
        int r;

        assert(s);

        r = unit_load_fragment_and_dropin_optional(u);
        if (r < 0)
                return r;

        /* This is a new unit? Then let's add in some extras */
        if (u->load_state == UNIT_LOADED) {

                r = unit_patch_contexts(u);
                if (r < 0)
                        return r;

                r = slice_add_parent_slice(s);
                if (r < 0)
                        return r;

                if (u->default_dependencies) {
                        r = slice_add_default_dependencies(s);
                        if (r < 0)
                                return r;
                }
        }

        return slice_verify(s);
}
Пример #9
0
static void slice_init(Unit *u) {
        Slice *s = SLICE(u);

        assert(u);
        assert(u->load_state == UNIT_STUB);

        cgroup_context_init(&s->cgroup_context);
}
Пример #10
0
void fn0040112B(word32 ecx, word32 edx, word32 ebx, word32 ebp, word32 edi, selector fs)
{
	byte al_15 = (byte) ebx;
	byte v12_20 = Mem0[ebx + 0x00000000:byte] + al_15;
	Mem21[ebx + 0x00000000:byte] = v12_20;
	byte v14_22 = Mem21[ebx + 0x00000000:byte] + al_15;
	Mem23[ebx + 0x00000000:byte] = v14_22;
	byte v15_24 = Mem23[ebx + 0x00000000:byte] + al_15;
	Mem25[ebx + 0x00000000:byte] = v15_24;
	byte v16_26 = Mem25[ebx + 0x00000000:byte] + al_15;
	Mem27[ebx + 0x00000000:byte] = v16_26;
	byte v17_28 = Mem27[ebx + 0x00000000:byte] + al_15;
	Mem29[ebx + 0x00000000:byte] = v17_28;
	byte v18_30 = Mem29[ebx + 0x00000000:byte] + al_15;
	Mem31[ebx + 0x00000000:byte] = v18_30;
	byte v19_32 = Mem31[ebx + 0x00000000:byte] + al_15;
	Mem33[ebx + 0x00000000:byte] = v19_32;
	byte v20_34 = Mem33[ebx + 0x00000000:byte] + al_15;
	Mem35[ebx + 0x00000000:byte] = v20_34;
	byte v21_36 = Mem35[ebx + 0x00000000:byte] + al_15;
	Mem37[ebx + 0x00000000:byte] = v21_36;
	byte v22_38 = Mem37[ebx + 0x00000000:byte] + al_15;
	Mem39[ebx + 0x00000000:byte] = v22_38;
	byte v23_40 = Mem39[ebx + 0x00000000:byte] + al_15;
	Mem41[ebx + 0x00000000:byte] = v23_40;
	byte v24_42 = Mem41[ebx + 0x00000000:byte] + al_15;
	Mem43[ebx + 0x00000000:byte] = v24_42;
	byte v25_44 = Mem43[ebx + 0x00000000:byte] + al_15;
	Mem45[ebx + 0x00000000:byte] = v25_44;
	byte v26_46 = Mem45[ebx + 0x00000000:byte] + al_15;
	Mem47[ebx + 0x00000000:byte] = v26_46;
	byte v27_48 = Mem47[ebx + 0x00000000:byte] + al_15;
	Mem49[ebx + 0x00000000:byte] = v27_48;
	byte v28_50 = Mem49[ebx + 0x00000000:byte] + al_15;
	Mem51[ebx + 0x00000000:byte] = v28_50;
	byte v29_52 = Mem51[ebx + 0x00000000:byte] + al_15;
	Mem53[ebx + 0x00000000:byte] = v29_52;
	word32 edi_10 = ~edi;
	word32 edi_55 = DPB(edi_10, (word16) edi_10 + 0xFF84, 0, 16);
	Mem53[0x00401093:word32]();
	word32 edi_96 = edi_55 + (ebp - 0xFFFFFFF9);
	word32 eax_89 = __rol(ebx, 0x05);
	word32 esp_112 = fp;
	word16 di_110 = (word16) edi_96;
	word32 ecx_99 = DPB(0x00009090, Mem53[ebp - 0xFFFFFFF9:word16] ^ 0x9090, 0, 16);
	byte dh_102 = SLICE((edx & 0x6AD47C2E) + 0x00000001 - 0x00000001, byte, 8);
	if (ecx_99 != 0x00000000)
	{
		ExitThread(edi_96);
		Mem283[ebx - 0x00000035:byte] = Mem53[ebx - 0x00000035:byte] + (byte) (eax_89 + edi_96 | 0x0014008D);
		word32 ecx_278 = DPB(ecx_99, 0x00, 8, 8);
		Mem288[ecx_278 + 0x00000000:byte] = Mem283[ecx_278 + 0x00000000:byte] + dh_102;
		word32 eax_290 = DPB(ecx_99, Mem288[0x00DDB800:byte], 0, 8);
		Mem292[eax_290 + 0x66017000 + eax_290:byte] = Mem288[eax_290 + 0x66017000 + eax_290:byte] + SLICE(ecx_99, byte, 8);
		di_110 = (word16) (edi_96 - 0x00000001);
		esp_112 = fp - 0x00000004;
	}
Пример #11
0
static int slice_serialize(Unit *u, FILE *f, FDSet *fds) {
        Slice *s = SLICE(u);

        assert(s);
        assert(f);
        assert(fds);

        unit_serialize_item(u, f, "state", slice_state_to_string(s->state));
        return 0;
}
Пример #12
0
static int slice_start(Unit *u) {
        Slice *t = SLICE(u);

        assert(t);
        assert(t->state == SLICE_DEAD);

        unit_realize_cgroup(u);

        slice_set_state(t, SLICE_ACTIVE);
        return 1;
}
Пример #13
0
static int slice_coldplug(Unit *u) {
        Slice *t = SLICE(u);

        assert(t);
        assert(t->state == SLICE_DEAD);

        if (t->deserialized_state != t->state)
                slice_set_state(t, t->deserialized_state);

        return 0;
}
Пример #14
0
void fn0C00_0100(word16 cx, segptr32 Eq_3::*bx, Eq_15 Eq_2::*di, Eq_3 * ds)
{
	Eq_2 * es_6 = SLICE(ds->*bx, selector, 16);
	bios_video_set_mode(0x13);
	while (true)
	{
		di = &di->b0000 + 0x0001;
		do
		{
			byte al_29 = 0x1E;
			if ((cl & 0x1E) != 0x00 && (ch & 0x1E) != 0x00)
				al_29 = (ch ^ cl) & 0x38;
			(es_6->*di).b0000 = al_29;
			cx = cx - 0x0001;
			di = di;
			cl = (byte) cx;
			ch = SLICE(cx, byte, 8);
		} while (cx != 0x0000);
	}
}
Пример #15
0
static int slice_stop(Unit *u) {
        Slice *t = SLICE(u);

        assert(t);
        assert(t->state == SLICE_ACTIVE);

        /* We do not need to destroy the cgroup explicitly,
         * unit_notify() will do that for us anyway. */

        slice_set_state(t, SLICE_DEAD);
        return 1;
}
Пример #16
0
static void slice_dump(Unit *u, FILE *f, const char *prefix) {
        Slice *t = SLICE(u);

        assert(t);
        assert(f);

        fprintf(f,
                "%sSlice State: %s\n",
                prefix, slice_state_to_string(t->state));

        cgroup_context_dump(&t->cgroup_context, f, prefix);
}
Пример #17
0
int bus_slice_set_property(
                Unit *u,
                const char *name,
                sd_bus_message *message,
                UnitSetPropertiesMode mode,
                sd_bus_error *error) {

        Slice *s = SLICE(u);

        assert(name);
        assert(u);

        return bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
}
Пример #18
0
DBusHandlerResult bus_slice_message_handler(Unit *u, DBusConnection *c, DBusMessage *message) {
        Slice *s = SLICE(u);

        const BusBoundProperties bps[] = {
                { "org.freedesktop.systemd1.Unit",  bus_unit_properties,           u },
                { "org.freedesktop.systemd1.Slice", bus_unit_cgroup_properties,    u },
                { "org.freedesktop.systemd1.Slice", bus_cgroup_context_properties, &s->cgroup_context },
                {}
        };

        SELINUX_UNIT_ACCESS_CHECK(u, c, message, "status");

        return bus_default_message_handler(c, message, INTROSPECTION, INTERFACES_LIST, bps);
}
Пример #19
0
void fn0C00_0100(byte cl, byte ah)
{
	bios_video_set_mode(0x13);
	do
	{
		cx = DPB(cx, 0xFA, 8, 8);
		do
		{
			ah = ah + ((byte) cx + SLICE(cx, byte, 8));
			(0xA000->*cx).bFFFFFFFF = ah;
			cx = cx - 0x0001;
		} while (cx != &Eq_13::t0000);
	} while (__inb(0x60) != 0x01);
	msdos_terminate_program20();
}
Пример #20
0
byte fn0C00_0171(Eq_92 * es, Eq_36 * ds, Eq_23 * fs, Eq_23 * gs)
{
	Eq_38 Eq_23::*bx_4 = ds->ptr01C6;
	ds->w01CE = (gs->*bx_4).w0000;
	word16 si_24 = (gs->*bx_4).w4000;
	word16 dx_107 = 0x0000;
	word16 bp_106 = 0x0000;
	byte Eq_92::*di_105 = &Eq_92::b0000;
	word16 cx_110 = 0x00C8;
	do
	{
		word16 cx_50 = 0x0140;
		di_54 = di_105;
		bp_55 = bp_106;
		dx_56 = dx_107;
		do
		{
			byte Eq_92::*di_54;
			word16 bp_55;
			word16 dx_56;
			dx_56 = dx_56 + ds->w01CE;
			bp_55 = bp_55 + si_24;
			Eq_140 bx_119 = DPB(bp_55, SLICE(dx_56, byte, 8), 0, 8);
			byte al_121 = 0x14;
			do
			{
				if (Mem7[fs:bx_119 + Mem7[ds:0x01CC:word16]:byte] != 0x00)
					break;
				bx_119 = bx_119 * 0x0002;
				al_121 = al_121 - 0x04;
			} while (al_121 != 0x00);
			es->*di_54 = al_121;
			di_54 = di_54 + 1;
			cx_50 = cx_50 - 0x0001;
		} while (cx_50 != 0x0000);
		di_105 = di_105 + 0x0140;
		bp_106 = bp_106 - ds->w01CE;
		dx_107 = dx_107 + si_24;
		cx_110 = cx_110 - 0x0001;
	} while (cx_110 != 0x0000);
	ds->b01C7 = ds->b01C7 + 0x01;
	byte v23_113 = ds->b01CD + 0x04;
	ds->b01CD = v23_113;
	return cond(v23_113);
}
Пример #21
0
void fn0C00_0100(byte ch, byte bh)
{
	bios_video_set_mode(0x13);
	byte bl_118 = 0x03;
	word16 bx_119 = DPB(bx, 0x03, 0, 8);
	do
	{
		cx = DPB(cx, 0xC8, 0, 8);
		byte Eq_25::*di_35 = &Eq_25::b0000;
		do
		{
			uint32 dx_ax_47 = cx *u cx;
			uint16 ax_110 = (word16) dx_ax_47;
			uint16 dx_112 = SLICE(dx_ax_47, word16, 16);
			word16 si_53 = 0x0280;
			do
			{
				uint16 dx_61 = SEQ(dx_112, ax_110 + 0x0281 - si_53) % bx_119;
				0xA000->*di_35 = (byte) dx_61 & 0x0F;
				word16 si_77 = si_53 - 0x0001;
				di_35 = di_35 + 1;
				ax_110 = dx_61;
				dx_112 = 0x0000;
				si_53 = si_77 - 0x0001;
			} while (si_77 != 0x0001);
			cx = cx - 0x0001;
		} while (cx != 0x0000);
		do
		{
			word16 ax_90 = DPB(ax_110, __inb(0x60), 0, 8);
			if (ax_90 == 0x0001)
				goto l0C00_013F;
			uint16 ax_108 = DPB(ax_90 - 0x0001, 0x0000->b046C & 0x0F, 0, 8);
			ax_110 = dx_122;
			dx_112 = ax_108;
			uint16 dx_122 = dx_112;
		} while ((byte) dx_122 - (byte) ax_108 <=u 0x00);
		bl_118 = bl_118 + 0x01;
		bx_119 = DPB(bx_119, bl_118, 0, 8);
	} while (bl_118 != 0x00);
	return;
}
Пример #22
0
int bus_slice_set_property(
                Unit *u,
                const char *name,
                DBusMessageIter *i,
                UnitSetPropertiesMode mode,
                DBusError *error) {

        Slice *s = SLICE(u);
        int r;

        assert(name);
        assert(u);
        assert(i);

        r = bus_cgroup_set_property(u, &s->cgroup_context, name, i, mode, error);
        if (r != 0)
                return r;

        return 0;
}
Пример #23
0
void fn0C00_0100(Eq_20 bx, word16 di, byte ah)
{
	bios_video_set_mode(0x12);
	uint16 ax_27 = DPB(ax, 0x12, 0, 8);
	word16 bp_28 = 0x0000;
	word16 cx_10 = 0x01E0;
	do
	{
		word16 wLoc02_34 = cx_10;
		word16 cx_35 = 0x027F;
		bp_28 = bp_28 - 0x027F + 0x0001;
		do
		{
			word16 cx_113 = 0x0000;
			byte cl_112 = 0x00;
			word16 dx_108 = SLICE(bx *u ax_27, word16, 16);
			do
			{
				Eq_20 ax_71 = (word16) ((dx_108 + bx) *s (bx - dx_108)) + bp_28;
				bx = ax_71;
				if (ax_71 > 0x0000)
					break;
				cl_112 = ~cl_112;
				dx_108 = dx_108 + di;
				cx_113 = DPB(cx_113, cl_112, 0, 8);
			} while (dx_108 != 0x0000);
			__syscall(0x10);
			wLoc02_34 = wLoc02_114;
			bx.u0 = 0x0000;
			ax_27 = DPB(cx_113, 0x0C, 8, 8);
			bp_28 = bp_28 + 0x0000;
			cx_35 = cx_35 - 0x0001;
			word16 wLoc02_114 = wLoc02_34;
		} while (cx_35 != 0x0000);
		di = di + 0x0001;
		cx_10 = wLoc02_114 - 0x0001;
	} while (cx_10 != 0x0000);
	__syscall(0x16);
	return;
}
Пример #24
0
static int slice_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
        Slice *s = SLICE(u);

        assert(u);
        assert(key);
        assert(value);
        assert(fds);

        if (streq(key, "state")) {
                SliceState state;

                state = slice_state_from_string(value);
                if (state < 0)
                        log_debug("Failed to parse state value %s", value);
                else
                        s->deserialized_state = state;

        } else
                log_debug("Unknown serialization key '%s'", key);

        return 0;
}
Пример #25
0
void fn0C00_0100()
{
	bios_video_set_mode(0x13);
	word16 ax_12 = 0x0013;
	Eq_9 Eq_17::*di_13 = &Eq_17::t0000;
	do
	{
		word16 ax_14 = ax_12 + di_13;
		Eq_13 al_17 = (byte) ax_14 + SLICE(ax_14, byte, 8);
		(0xA000->*di_13).t0000 = al_17;
		Eq_9 Eq_17::*di_20 = di_13 + 1;
		ax_12 = DPB(ax_14, al_17, 0, 8);
		di_13 = di_20;
	} while (di_20 != &Eq_17::t0000);
	Mem26[ss:fp - 0x0002:word16] = 0xA000;
	Eq_13 Eq_17::*si_30 = Eq_17::a002D;
	while (true)
	{
		Mem34[0xA000:di_13 + 0x0000:word16] = Mem26[0xA000:si_30 + 0x0000:word16];
		si_30 = si_30 + 1;
		di_13 = di_13 + 2;
	}
}
Пример #26
0
void fn0C00_0100(byte bh, Eq_10 * ds)
{
	bios_video_set_mode(0x13);
	Eq_9 Eq_10::*si_18 = &Eq_10::t01BC;
	do
	{
		word16 ax_17 = Mem0[ds:si_18 + 0x0000:word16];
		byte dh_22 = SLICE(ax_17, byte, 8);
		bios_video_set_cursor_position(bh, dh_22, (byte) ax_17);
		si_18 = si_18 + 0x0002 + 0x0001;
		dx = ax_17;
		word16 ax_25 = DPB(dx, 0x02, 8, 8);
		do
		{
			byte al_30 = Mem0[ds:si_18 + 0x0000:byte];
			msdos_write_console_char(al_30);
			ax_25 = DPB(ax_25, al_30, 0, 8);
			si_18 = si_18;
			dx = DPB(dx, al_30, 0, 8);
		} while (al_30 != 0x00);
	} while (dh_22 != 0x00);
	do
	{
		__outb(0x03C9, al_30);
		word16 ax_50 = __rol(DPB(ax_25, ~al_30, 0, 8), 0x01);
		__outb(0x03C9, (byte) ax_50);
		word16 ax_53 = __ror(ax_50, 0x01);
		byte al_54 = (byte) ax_53;
		__outb(0x03C9, al_54);
		word16 ax_57 = DPB(ax_53, ~al_54, 0, 8);
		ax_25 = ax_57 + 0x0001;
		al_30 = (byte) (ax_57 + 0x0001);
	} while (ax_57 != 0x0001);
	Eq_79 Eq_104::*di_111 = Eq_104::a0000;
	byte bl_116 = 0xCC;
	word16 bx_114 = DPB(bx, 0xCC, 0, 8);
	do
	{
		word16 cx_112 = 0x0140;
		byte cl_113 = 0x40;
		do
		{
			Eq_93 al_107;
			if ((0xA000->*di_111).t0000 == 0x00)
			{
				word16 ax_160 = __aam(cl_113 | bl_116);
				al_107 = ((byte) ax_160 | SLICE(ax_160, byte, 8)) & 0x3F;
			}
			else
			{
				Eq_87 al_168 = cl_113 - bl_116;
				al_107 = al_168 - cl_113 - (al_168 <u 0x00);
			}
			(0xA000->*di_111).t0000 = al_107;
			cx_112 = cx_112 - 0x0001;
			di_111 = di_111 + 1;
			cl_113 = (byte) cx_112;
		} while (cx_112 != 0x0000);
		bx_114 = bx_114 - 0x0001;
		bl_116 = (byte) bx_114;
	} while (bx_114 != 0x0000);
	__outb(0x0331, 0x3F);
	Mem129[ss:fp - 0x0002:word16] = 0xFA00;
	byte Eq_104::*si_122 = Eq_104::a0000;
	byte Eq_104::*di_125 = Eq_104::aFFFFFA00;
	word16 cx_126 = 0x0140;
	do
	{
		0xA000->*di_125 = 0xA000->*si_122;
		si_122 = si_122 + 1;
		di_125 = di_125 + 1;
		cx_126 = cx_126 - 0x0001;
	} while (cx_126 != 0x0000);
	Mem151[ss:fp - 0x0002:word16] = 0x0177;
	do
		;
	while (((byte) __inw(0x03DA) & 0x08) == 0x00);
	return;
}
Пример #27
0
_pure_ static const char *slice_sub_state_to_string(Unit *u) {
        assert(u);

        return slice_state_to_string(SLICE(u)->state);
}
Пример #28
0
_pure_ static UnitActiveState slice_active_state(Unit *u) {
        assert(u);

        return state_translation_table[SLICE(u)->state];
}