C++ reg函数代码示例

void cgLdCns(IRLS& env, const IRInstruction* inst) {
  auto const cnsName = inst->src(0)->strVal();
  auto const ch = makeCnsHandle(cnsName, false);
  auto const dst = dstLoc(env, inst, 0);
  auto& v = vmain(env);
  assertx(inst->taken());

  if (rds::isNormalHandle(ch)) {
    auto const sf = checkRDSHandleInitialized(v, ch);
    fwdJcc(v, env, CC_NE, sf, inst->taken());
    loadTV(v, inst->dst(), dst, rvmtl()[ch]);
    return;
  }
  assertx(rds::isPersistentHandle(ch));

  auto const& cns = rds::handleToRef<TypedValue>(ch);

  if (cns.m_type == KindOfUninit) {
    loadTV(v, inst->dst(), dst, rvmtl()[ch]);
    auto const sf = v.makeReg();
    irlower::emitTypeTest(
      v, env, TUninit, dst.reg(1), dst.reg(0), sf,
      [&] (ConditionCode cc, Vreg sf) {
        fwdJcc(v, env, cc, sf, inst->taken());
      }
    );
  } else {
    // Statically known constant.
    assertx(!dst.isFullSIMD());
    switch (cns.m_type) {
      case KindOfNull:
        v << copy{v.cns(nullptr), dst.reg(0)};
        break;
      case KindOfBoolean:
        v << copy{v.cns(!!cns.m_data.num), dst.reg(0)};
        break;
      case KindOfInt64:
      case KindOfPersistentString:
      case KindOfPersistentVec:
      case KindOfPersistentDict:
      case KindOfPersistentKeyset:
      case KindOfPersistentArray:
      case KindOfString:
      case KindOfVec:
      case KindOfDict:
      case KindOfKeyset:
      case KindOfArray:
      case KindOfObject:
      case KindOfResource:
      case KindOfRef:
        v << copy{v.cns(cns.m_data.num), dst.reg(0)};
        break;
      case KindOfDouble:
        v << copy{v.cns(cns.m_data.dbl), dst.reg(0)};
        break;
      case KindOfUninit:
      case KindOfClass:
        not_reached();
    }
    v << copy{v.cns(cns.m_type), dst.reg(1)};
  }
}

/*
 - regcomp - compile a regular expression into internal code
 *
 * We can't allocate space until we know how big the compiled form will be,
 * but we can't compile it (and thus know how big it is) until we've got a
 * place to put the code.  So we cheat:  we compile it twice, once with code
 * generation turned off and size counting turned on, and once "for real".
 * This also means that we don't allocate space until we are sure that the
 * thing really will compile successfully, and we never have to move the
 * code and thus invalidate pointers into it.  (Note that it has to be in
 * one piece because free() must be able to free it all.)
 *
 * Beware that the optimization-preparation code in here knows about some
 * of the structure of the compiled regexp.
 */
int regcomp(regex_t *preg, const char *exp, int cflags)
{
	int scan;
	int longest;
	unsigned len;
	int flags;

#ifdef DEBUG
	fprintf(stderr, "Compiling: '%s'\n", exp);
#endif
	memset(preg, 0, sizeof(*preg));

	if (exp == NULL)
		FAIL(preg, REG_ERR_NULL_ARGUMENT);

	/* First pass: determine size, legality. */
	preg->cflags = cflags;
	preg->regparse = exp;

	/* Allocate space. */
	preg->proglen = (strlen(exp) + 1) * 5;
	preg->program = malloc(preg->proglen * sizeof(int));
	if (preg->program == NULL)
		FAIL(preg, REG_ERR_NOMEM);

	/* Note that since we store a magic value as the first item in the program,
	 * program offsets will never be 0
	 */
	regc(preg, REG_MAGIC);
	if (reg(preg, 0, &flags) == 0) {
		return preg->err;
	}

	/* Small enough for pointer-storage convention? */
	if (preg->re_nsub >= REG_MAX_PAREN)		/* Probably could be 65535L. */
		FAIL(preg,REG_ERR_TOO_BIG);

	/* Dig out information for optimizations. */
	preg->regstart = 0;	/* Worst-case defaults. */
	preg->reganch = 0;
	preg->regmust = 0;
	preg->regmlen = 0;
	scan = 1;			/* First BRANCH. */
	if (OP(preg, regnext(preg, scan)) == END) {		/* Only one top-level choice. */
		scan = OPERAND(scan);

		/* Starting-point info. */
		if (OP(preg, scan) == EXACTLY) {
			preg->regstart = preg->program[OPERAND(scan)];
		}
		else if (OP(preg, scan) == BOL)
			preg->reganch++;

		/*
		 * If there's something expensive in the r.e., find the
		 * longest literal string that must appear and make it the
		 * regmust.  Resolve ties in favor of later strings, since
		 * the regstart check works with the beginning of the r.e.
		 * and avoiding duplication strengthens checking.  Not a
		 * strong reason, but sufficient in the absence of others.
		 */
		if (flags&SPSTART) {
			longest = 0;
			len = 0;
			for (; scan != 0; scan = regnext(preg, scan)) {
				if (OP(preg, scan) == EXACTLY) {
					int plen = str_int_len(preg->program + OPERAND(scan));
					if (plen >= len) {
						longest = OPERAND(scan);
						len = plen;
					}
				}
			}
			preg->regmust = longest;
			preg->regmlen = len;
		}
	}

#ifdef DEBUG
	regdump(preg);
#endif

	return 0;
}

void Serveur::readServeur()
{
        QString message=QString::fromUtf8(this->readAll());


	QString currentChan=tab->tabText(tab->currentIndex());

	if(message.startsWith("PING :"))
	{
		QStringList liste=message.split(" ");
		QString msg="PONG "+liste.at(1);
		sendData(msg);
	}
	else if(message.contains("Nickname is already in use."))
	{
        pseudo=pseudo+"_2";
		pseudo.remove("\r\n");
		sendData("NICK "+pseudo);
		emit pseudoChanged(pseudo);
        ecrire("-> Name changed to "+pseudo);
	}
        else if(updateUsers==true)
	{
		updateUsersList("",message);
	}

    QStringList list=message.split("\r\n");
        foreach(QString msg,list)
        {
            if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ PRIVMSG ([a-zA-Z0-9\\#]+) :(.+)")))
            {
                QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ PRIVMSG ([a-zA-Z0-9\\#]+) :(.+)");
                QString msg2=msg;
                    ecrire(msg.replace(reg,"\\2 <b>&lt;\\1&gt;</b> \\3"),"",msg2.replace(reg,"\\2 <\\1> \\3"));
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ JOIN ([a-zA-Z0-9\\#]+)")))
            {
                QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ JOIN ([a-zA-Z0-9\\#]+)");
                QString msg2=msg;
                ecrire(msg.replace(reg,"\\2 <i>-> \\1 join \\2</i><br />"),"",msg2.replace(reg,"-> \\1 join \\2"));
                updateUsersList(msg.replace(reg,"\\2"));
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ PART ([a-zA-Z0-9\\#]+)")))
            {
                QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ PART ([a-zA-Z0-9\\#]+) :(.+)");
                QString msg2=msg;
                ecrire(msg.replace(reg,"\\2 <i>-> \\1 quit \\2 (\\3)</i><br />"),"",msg2.replace(reg,"-> \\1 quit \\2"));
                updateUsersList(msg.replace(reg,"\\2"));
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ QUIT (.+)")))
            {
                QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ QUIT (.+)");
                QString msg2=msg;
                ecrire(msg.replace(reg,"\\2 <i>-> \\1 quit this server (\\2)</i><br />"),"",msg2.replace(reg,"-> \\1 left"));
                updateUsersList(msg.replace(reg,"\\2"));
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ NICK :(.+)")))
            {
                QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ NICK :(.+)");
                QString msg2=msg;
                ecrire(msg.replace(reg,"<i>\\1 is now called \\2</i><br />"),"",msg2.replace(reg,"-> \\1 is now called \\2"));
                updateUsersList(currentChan);
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ KICK ([a-zA-Z0-9\\#]+) ([a-zA-Z0-9]+) :(.+)")))
            { 
                QRegExp reg(":([a-zA-Z0-9]+)\\!~[a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ KICK ([a-zA-Z0-9\\#]+) ([a-zA-Z0-9]+) :(.+)");
                QString msg2=msg;
                ecrire(msg.replace(reg,"\\2 <i>-> \\1 kicked \\3 (\\4)</i><br />"),"",msg2.replace(reg,"-> \\1 quit \\3"));
                updateUsersList(msg.replace(reg,"\\2"));
            }
            else if(msg.contains(QRegExp(":([a-zA-Z0-9]+)\\![a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ NOTICE ([a-zA-Z0-9]+) :(.+)")))
            {
                if(conversations.contains(currentChan))
                {
                    QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ NOTICE [a-zA-Z0-9]+ :(.+)");
                    ecrire(msg.replace(reg,"<b>[NOTICE] <i>\\1</i> : \\2 <br />"),currentChan);
                }
                else if(currentChan==serveur)
                {
                    QRegExp reg(":([a-zA-Z0-9]+)\\![~a-zA-Z0-9][email protected][a-zA-Z0-9\\/\\.-]+ NOTICE [a-zA-Z0-9]+ :(.+)");
                    ecrire(msg.replace(reg,"<b>[NOTICE] <i>\\1</i> : \\2 <br />"));
                }
            }
            else if(msg.contains("/MOTD command."))
            {
             joins();


            }
            else if(msg.contains(QRegExp("= ([a-zA-Z0-9\\#]+) :")))
            {

             QStringList msg3 = msg.split("= ");
             QStringList msg4 = msg3[1].split(" :");
             updateUsersList(msg4[0],msg);
            }


        }

//.........这里部分代码省略.........

char uart_read(int channel) {
	return *reg(channel, UART_DATA_OFFSET);
}

/*
 - regcomp - compile a regular expression into internal code
 *
 * We can't allocate space until we know how big the compiled form will be,
 * but we can't compile it (and thus know how big it is) until we've got a
 * place to put the code.  So we cheat:  we compile it twice, once with code
 * generation turned off and size counting turned on, and once "for real".
 * This also means that we don't allocate space until we are sure that the
 * thing really will compile successfully, and we never have to move the
 * code and thus invalidate pointers into it.  (Note that it has to be in
 * one piece because free() must be able to free it all.)
 *
 * Beware that the optimization-preparation code in here knows about some
 * of the structure of the compiled regexp.
 */
cst_regex *
hs_regcomp(const char *exp)
{
        cst_regex *r;
	char *scan;
	char *longest;
	unsigned int len;
	int flags;
	if (exp == NULL)
		FAIL("NULL argument");

	/* First pass: determine size, legality. */
#ifdef notdef
	if (exp[0] == '.' && exp[1] == '*') exp += 2;  /* aid grep */
#endif
	regparse = exp;
	regnpar = 1;
	regsize = 0L;
	regcode = &regdummy;
	regc(CST_REGMAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Small enough for pointer-storage convention? */
	if (regsize >= 32767L)		/* Probably could be 65535L. */
		FAIL("regexp too big");

	/* Allocate space. */
	r = cst_alloc(cst_regex,1);
	r->regsize = regsize;
	r->program = cst_alloc(char,regsize);
	if (r == NULL)
		FAIL("out of space");

	/* Second pass: emit code. */
	regparse = exp;
	regnpar = 1;
	regcode = r->program;
	regc(CST_REGMAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Dig out information for optimizations. */
	r->regstart = '\0';	/* Worst-case defaults. */
	r->reganch = 0;
	r->regmust = NULL;
	r->regmlen = 0;
	scan = r->program+1;			/* First BRANCH. */

	if (OP(regnext(scan)) == END) {		/* Only one top-level choice. */
		scan = OPERAND(scan);

		/* Starting-point info. */
		if (OP(scan) == EXACTLY)
			r->regstart = *OPERAND(scan);
		else if (OP(scan) == BOL)
			r->reganch++;

		/*
		 * If there's something expensive in the r.e., find the
		 * longest literal string that must appear and make it the
		 * regmust.  Resolve ties in favor of later strings, since
		 * the regstart check works with the beginning of the r.e.
		 * and avoiding duplication strengthens checking.  Not a
		 * strong reason, but sufficient in the absence of others.
		 */
		if (flags&SPSTART) {
			longest = NULL;
			len = 0;
			for (; scan != NULL; scan = regnext(scan))
				if ((OP(scan) == EXACTLY) && 
				    (strlen(OPERAND(scan)) >= len)) {
					longest = OPERAND(scan);
					len = strlen(OPERAND(scan));
				}
			r->regmust = longest;
			r->regmlen = len;
		}
	}
	return(r);

}

void uart_clear_modem_irq(int channel) {
#ifndef QEMU
	*reg(channel, UART_INTR_OFFSET) = 0;
#endif
}

int uart_err(int channel) {
	return *reg(channel, UART_RSR_OFFSET); // TODO
}

void test_addressing_modes() {
	asm_p as = &(asm_t){ 0 };
	char* disassembly = NULL;
	as_new(as);
	
	// reg reg
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_mov(as, reg(i), reg(i));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"mov    rax,rax\n"
		"mov    rcx,rcx\n"
		"mov    rdx,rdx\n"
		"mov    rbx,rbx\n"
		"mov    rsp,rsp\n"
		"mov    rbp,rbp\n"
		"mov    rsi,rsi\n"
		"mov    rdi,rdi\n"
		"mov    r8,r8\n"
		"mov    r9,r9\n"
		"mov    r10,r10\n"
		"mov    r11,r11\n"
		"mov    r12,r12\n"
		"mov    r13,r13\n"
		"mov    r14,r14\n"
		"mov    r15,r15\n"
	);
	
	// reg [RIP + displ]
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_mov(as, reg(i), reld(0xbeba));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"mov    rax,QWORD PTR [rip+0xbeba]        # 0x40bec1\n"
		"mov    rcx,QWORD PTR [rip+0xbeba]        # 0x40bec8\n"
		"mov    rdx,QWORD PTR [rip+0xbeba]        # 0x40becf\n"
		"mov    rbx,QWORD PTR [rip+0xbeba]        # 0x40bed6\n"
		"mov    rsp,QWORD PTR [rip+0xbeba]        # 0x40bedd\n"
		"mov    rbp,QWORD PTR [rip+0xbeba]        # 0x40bee4\n"
		"mov    rsi,QWORD PTR [rip+0xbeba]        # 0x40beeb\n"
		"mov    rdi,QWORD PTR [rip+0xbeba]        # 0x40bef2\n"
		"mov    r8,QWORD PTR [rip+0xbeba]        # 0x40bef9\n"
		"mov    r9,QWORD PTR [rip+0xbeba]        # 0x40bf00\n"
		"mov    r10,QWORD PTR [rip+0xbeba]        # 0x40bf07\n"
		"mov    r11,QWORD PTR [rip+0xbeba]        # 0x40bf0e\n"
		"mov    r12,QWORD PTR [rip+0xbeba]        # 0x40bf15\n"
		"mov    r13,QWORD PTR [rip+0xbeba]        # 0x40bf1c\n"
		"mov    r14,QWORD PTR [rip+0xbeba]        # 0x40bf23\n"
		"mov    r15,QWORD PTR [rip+0xbeba]        # 0x40bf2a\n"
	);
	
	// reg [displ]
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_mov(as, reg(i), memd(0xbeba));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		// Funny syntax when disassembling with intel syntax. Looks normal with
		// GNU syntax.
		"mov    rax,QWORD PTR ds:0xbeba\n"
		"mov    rcx,QWORD PTR ds:0xbeba\n"
		"mov    rdx,QWORD PTR ds:0xbeba\n"
		"mov    rbx,QWORD PTR ds:0xbeba\n"
		"mov    rsp,QWORD PTR ds:0xbeba\n"
		"mov    rbp,QWORD PTR ds:0xbeba\n"
		"mov    rsi,QWORD PTR ds:0xbeba\n"
		"mov    rdi,QWORD PTR ds:0xbeba\n"
		"mov    r8,QWORD PTR ds:0xbeba\n"
		"mov    r9,QWORD PTR ds:0xbeba\n"
		"mov    r10,QWORD PTR ds:0xbeba\n"
		"mov    r11,QWORD PTR ds:0xbeba\n"
		"mov    r12,QWORD PTR ds:0xbeba\n"
		"mov    r13,QWORD PTR ds:0xbeba\n"
		"mov    r14,QWORD PTR ds:0xbeba\n"
		"mov    r15,QWORD PTR ds:0xbeba\n"
	);
	
	// reg [reg + displ]
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_mov(as, reg(i), memrd(reg(i), 0xbeba));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"mov    rax,QWORD PTR [rax+0xbeba]\n"
		"mov    rcx,QWORD PTR [rcx+0xbeba]\n"
		"mov    rdx,QWORD PTR [rdx+0xbeba]\n"
		"mov    rbx,QWORD PTR [rbx+0xbeba]\n"
		"mov    rsp,QWORD PTR [rsp+0xbeba]\n"
		"mov    rbp,QWORD PTR [rbp+0xbeba]\n"
		"mov    rsi,QWORD PTR [rsi+0xbeba]\n"
		"mov    rdi,QWORD PTR [rdi+0xbeba]\n"
		"mov    r8,QWORD PTR [r8+0xbeba]\n"
		"mov    r9,QWORD PTR [r9+0xbeba]\n"
		"mov    r10,QWORD PTR [r10+0xbeba]\n"
		"mov    r11,QWORD PTR [r11+0xbeba]\n"
		"mov    r12,QWORD PTR [r12+0xbeba]\n"
		"mov    r13,QWORD PTR [r13+0xbeba]\n"
		"mov    r14,QWORD PTR [r14+0xbeba]\n"
//.........这里部分代码省略.........

void test_compare_instructions() {
	asm_p as = &(asm_t){ 0 };
	char* disassembly = NULL;
	as_new(as);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_cmp(as, reg(i), reg(i));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"cmp    rax,rax\n"
		"cmp    rcx,rcx\n"
		"cmp    rdx,rdx\n"
		"cmp    rbx,rbx\n"
		"cmp    rsp,rsp\n"
		"cmp    rbp,rbp\n"
		"cmp    rsi,rsi\n"
		"cmp    rdi,rdi\n"
		"cmp    r8,r8\n"
		"cmp    r9,r9\n"
		"cmp    r10,r10\n"
		"cmp    r11,r11\n"
		"cmp    r12,r12\n"
		"cmp    r13,r13\n"
		"cmp    r14,r14\n"
		"cmp    r15,r15\n"
	);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_cmp(as, reg(i), memrd(reg(i), 0xbeba));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"cmp    rax,QWORD PTR [rax+0xbeba]\n"
		"cmp    rcx,QWORD PTR [rcx+0xbeba]\n"
		"cmp    rdx,QWORD PTR [rdx+0xbeba]\n"
		"cmp    rbx,QWORD PTR [rbx+0xbeba]\n"
		"cmp    rsp,QWORD PTR [rsp+0xbeba]\n"
		"cmp    rbp,QWORD PTR [rbp+0xbeba]\n"
		"cmp    rsi,QWORD PTR [rsi+0xbeba]\n"
		"cmp    rdi,QWORD PTR [rdi+0xbeba]\n"
		"cmp    r8,QWORD PTR [r8+0xbeba]\n"
		"cmp    r9,QWORD PTR [r9+0xbeba]\n"
		"cmp    r10,QWORD PTR [r10+0xbeba]\n"
		"cmp    r11,QWORD PTR [r11+0xbeba]\n"
		"cmp    r12,QWORD PTR [r12+0xbeba]\n"
		"cmp    r13,QWORD PTR [r13+0xbeba]\n"
		"cmp    r14,QWORD PTR [r14+0xbeba]\n"
		"cmp    r15,QWORD PTR [r15+0xbeba]\n"
	);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_cmp(as, reg(i), imm(0x11223344));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"cmp    rax,0x11223344\n"
		"cmp    rcx,0x11223344\n"
		"cmp    rdx,0x11223344\n"
		"cmp    rbx,0x11223344\n"
		"cmp    rsp,0x11223344\n"
		"cmp    rbp,0x11223344\n"
		"cmp    rsi,0x11223344\n"
		"cmp    rdi,0x11223344\n"
		"cmp    r8,0x11223344\n"
		"cmp    r9,0x11223344\n"
		"cmp    r10,0x11223344\n"
		"cmp    r11,0x11223344\n"
		"cmp    r12,0x11223344\n"
		"cmp    r13,0x11223344\n"
		"cmp    r14,0x11223344\n"
		"cmp    r15,0x11223344\n"
	);
	
	free(disassembly);
}

//.........这里部分代码省略.........
			(*info->fprintf_func) (stream, "pn");
			++s;
			continue;

		      case 'T':
			(*info->fprintf_func) (stream, "pt");
			++s;
			continue;

		      default:
			break;
		      }
		  }

		(*info->fprintf_func) (stream, " ");

		switch (*s)
		  {
		  case '+':
		    found_plus = 1;
		    /* Fall through.  */

		  default:
		    (*info->fprintf_func) (stream, "%c", *s);
		    break;

		  case '#':
		    (*info->fprintf_func) (stream, "0");
		    break;

#define	reg(n)	(*info->fprintf_func) (stream, "%%%s", reg_names[n])
		  case '1':
		  case 'r':
		    reg (X_RS1 (insn));
		    break;

		  case '2':
		  case 'O':
		    reg (X_RS2 (insn));
		    break;

		  case 'd':
		    reg (X_RD (insn));
		    break;
#undef	reg

#define	freg(n)		(*info->fprintf_func) (stream, "%%%s", freg_names[n])
#define	fregx(n)	(*info->fprintf_func) (stream, "%%%s", freg_names[((n) & ~1) | (((n) & 1) << 5)])
		  case 'e':
		    freg (X_RS1 (insn));
		    break;
		  case 'v':	/* Double/even.  */
		  case 'V':	/* Quad/multiple of 4.  */
		    fregx (X_RS1 (insn));
		    break;

		  case 'f':
		    freg (X_RS2 (insn));
		    break;
		  case 'B':	/* Double/even.  */
		  case 'R':	/* Quad/multiple of 4.  */
		    fregx (X_RS2 (insn));
		    break;

		  case 'g':
		    freg (X_RD (insn));

void test_arithmetic_instructions() {
	asm_p as = &(asm_t){ 0 };
	char* disassembly = NULL;
	as_new(as);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_add(as, reg(i), reg(i));
		for(size_t i = 0; i < 16; i++)
			as_add(as, reg(i), imm(0x7abbccdd));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"add    rax,rax\n"
		"add    rcx,rcx\n"
		"add    rdx,rdx\n"
		"add    rbx,rbx\n"
		"add    rsp,rsp\n"
		"add    rbp,rbp\n"
		"add    rsi,rsi\n"
		"add    rdi,rdi\n"
		"add    r8,r8\n"
		"add    r9,r9\n"
		"add    r10,r10\n"
		"add    r11,r11\n"
		"add    r12,r12\n"
		"add    r13,r13\n"
		"add    r14,r14\n"
		"add    r15,r15\n"
		"add    rax,0x7abbccdd\n"
		"add    rcx,0x7abbccdd\n"
		"add    rdx,0x7abbccdd\n"
		"add    rbx,0x7abbccdd\n"
		"add    rsp,0x7abbccdd\n"
		"add    rbp,0x7abbccdd\n"
		"add    rsi,0x7abbccdd\n"
		"add    rdi,0x7abbccdd\n"
		"add    r8,0x7abbccdd\n"
		"add    r9,0x7abbccdd\n"
		"add    r10,0x7abbccdd\n"
		"add    r11,0x7abbccdd\n"
		"add    r12,0x7abbccdd\n"
		"add    r13,0x7abbccdd\n"
		"add    r14,0x7abbccdd\n"
		"add    r15,0x7abbccdd\n"
	);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_sub(as, reg(i), reg(i));
		for(size_t i = 0; i < 16; i++)
			as_sub(as, reg(i), imm(0x7abbccdd));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"sub    rax,rax\n"
		"sub    rcx,rcx\n"
		"sub    rdx,rdx\n"
		"sub    rbx,rbx\n"
		"sub    rsp,rsp\n"
		"sub    rbp,rbp\n"
		"sub    rsi,rsi\n"
		"sub    rdi,rdi\n"
		"sub    r8,r8\n"
		"sub    r9,r9\n"
		"sub    r10,r10\n"
		"sub    r11,r11\n"
		"sub    r12,r12\n"
		"sub    r13,r13\n"
		"sub    r14,r14\n"
		"sub    r15,r15\n"
		"sub    rax,0x7abbccdd\n"
		"sub    rcx,0x7abbccdd\n"
		"sub    rdx,0x7abbccdd\n"
		"sub    rbx,0x7abbccdd\n"
		"sub    rsp,0x7abbccdd\n"
		"sub    rbp,0x7abbccdd\n"
		"sub    rsi,0x7abbccdd\n"
		"sub    rdi,0x7abbccdd\n"
		"sub    r8,0x7abbccdd\n"
		"sub    r9,0x7abbccdd\n"
		"sub    r10,0x7abbccdd\n"
		"sub    r11,0x7abbccdd\n"
		"sub    r12,0x7abbccdd\n"
		"sub    r13,0x7abbccdd\n"
		"sub    r14,0x7abbccdd\n"
		"sub    r15,0x7abbccdd\n"
	);
	
	as_clear(as);
		for(size_t i = 0; i < 16; i++)
			as_mul(as, reg(i));
		for(size_t i = 0; i < 16; i++)
			as_mul(as, memrd(reg(i), 0xbeba));
	disassembly = disassemble(as);
	st_check_str(disassembly,
		"mul    rax\n"
		"mul    rcx\n"
		"mul    rdx\n"
		"mul    rbx\n"
		"mul    rsp\n"
		"mul    rbp\n"
//.........这里部分代码省略.........

void UFindReplaceTextDialog::find(bool next)
{
    if(!textEdit)
        return;

    // backward search
    bool up = !next;

    const QString toSearch = lineEditFindText->text();

    bool result = false;

    QTextDocument::FindFlags flags;

    bool caseSensitive      = checkBoxCaseSensitive->isChecked();
    bool wholeWords         = checkBoxWholeWords->isChecked();
    bool regularExpressions = checkBoxRegExp->isChecked();

    if(up)
        flags |= QTextDocument::FindBackward;

    if(caseSensitive)
        flags |= QTextDocument::FindCaseSensitively;

    if(wholeWords)
        flags |= QTextDocument::FindWholeWords;

    QTextCursor _textCursor = textEdit->textCursor();

    if(regularExpressions)
    {
        QRegExp reg(toSearch,
                    caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);

        _textCursor = textEdit->document()->find(reg, _textCursor, flags);
        result = !_textCursor.isNull();

    }else
        result = textEdit->find(toSearch, flags);

    if(result)
        showError("");

    else
    {
        showError(strNoMatchFound);

        // move to the beginning of the document for the next find
        _textCursor.setPosition(0);
        textEdit->setTextCursor(_textCursor);
    }

    if(!regularExpressions)
        _textCursor = textEdit->textCursor();

    textCursor = _textCursor;

    _textCursor.clearSelection();
    textEdit->setTextCursor(_textCursor);

    if(textCursor.hasSelection())
    {
        QTextEdit::ExtraSelection selection;
        QTextCharFormat format;
        format.setBackground(colorSelection);
        selection.format = format;
        selection.cursor = textCursor;
        textEdit->setExtraSelections(QList <QTextEdit::ExtraSelection>()
                                     << selection);
    }
}

void QGenieSmartnetworkThread::doCmdAttachDevice(const QStringList &reqlist, QStringList &retlist)
{
    retlist.clear();
    if(reqlist.count()<1)
    {
        retlist<<"-1"<<"lack parameter";
        return;
    }
    QMap<QString,QString> paras;
    int iret;
    QString sret;

    const QDomNode &node=doFunc(reqlist[0]
                                ,"DeviceInfo"
                               ,"GetAttachDevice"
                                ,&iret,&sret
                                ,paras);
    if(iret!=0)
    {
        retlist<<QString::number(iret)<<sret;
        return;
    }

    QDomElement elem=node.firstChild().toElement();
    retlist<<elem.attribute("_responseCode");
    QString stemp=elem.attribute("NewAttachDevice");

    if(stemp.isEmpty())
    {
        retlist<<"0"<<"0";
    }
    else
    {
        //[email protected];192.168.1.2;geines-Mac-mini;28:37:37:12:09:2F;wireless;54;86;[email protected];192.168.1.6;xgywz-PC;00:1D:0F:33:08:1C;wireless;54;87;[email protected];192.168.1.10;Android_359836041571187;A8:26:D9:CB:2E:A4;wireless;54;79;[email protected];192.168.1.11;Android_357710047293728;64:A7:69:3F:E6:E9;wireless;54;67;[email protected];192.168.1.14;android_8eb092bb95e89cf;C8:AA:21:80:A8:F1;wireless;54;87;[email protected];192.168.1.15;--;28:37:37:12:C6:9D;wireless;54;86;[email protected];192.168.1.29;PC2011110909BPO;14:E6:E4:06:F8:E8;wireless;54;92;Allow
        QRegExp reg("@\\d+;");
        QStringList slist=stemp.split(reg);
        qDebug()<<slist;

        int c=slist.count();
        if(c<1)
        {
            retlist<<"0"<<"0";
        }
        else
        {
            retlist<<"0";
            for(int i=0;i<c;i++)
            {
                QStringList ssublist=slist[i].split(";");
                int cc=ssublist.count();

                for(int j=0;j<cc;j++)
                {
                    retlist<<ssublist[j];
                }
                if(1==i)
                {
                    retlist.insert(2,QString::number(cc));
                }

            }
        }
    }

}

void PreferencesNetwork::syncSettings()
{
	auto cloud = qPrefCloudStorage::instance();
	auto proxy = qPrefProxy::instance();

	proxy->set_proxy_type(ui->proxyType->itemData(ui->proxyType->currentIndex()).toInt());
	proxy->set_proxy_host(ui->proxyHost->text());
	proxy->set_proxy_port(ui->proxyPort->value());
	proxy->set_proxy_auth(ui->proxyAuthRequired->isChecked());
	proxy->set_proxy_user(ui->proxyUsername->text());
	proxy->set_proxy_pass(ui->proxyPassword->text());

	QString email = ui->cloud_storage_email->text();
	QString password = ui->cloud_storage_password->text();
	QString newpassword = ui->cloud_storage_new_passwd->text();

	//TODO: Change this to the Cloud Storage Stuff, not preferences.
	if (prefs.cloud_verification_status == qPref::CS_VERIFIED && !newpassword.isEmpty()) {
		// deal with password change
		if (!email.isEmpty() && !password.isEmpty()) {
			// connect to backend server to check / create credentials
			QRegularExpression reg("^[[email protected]+_-]+$");
			if (!reg.match(email).hasMatch() || (!password.isEmpty() && !reg.match(password).hasMatch())) {
				report_error(qPrintable(tr("Change ignored. Cloud storage email and password can only consist of letters, numbers, and '.', '-', '_', and '+'.")));
				return;
			}
			if (!reg.match(email).hasMatch() || (!newpassword.isEmpty() && !reg.match(newpassword).hasMatch())) {
				report_error(qPrintable(tr("Change ignored. Cloud storage email and new password can only consist of letters, numbers, and '.', '-', '_', and '+'.")));
				ui->cloud_storage_new_passwd->setText("");
				return;
			}
			CloudStorageAuthenticate *cloudAuth = new CloudStorageAuthenticate(this);
			connect(cloudAuth, &CloudStorageAuthenticate::finishedAuthenticate, this, &PreferencesNetwork::updateCloudAuthenticationState);
			connect(cloudAuth, &CloudStorageAuthenticate::passwordChangeSuccessful, this, &PreferencesNetwork::passwordUpdateSuccessful);
			cloudAuth->backend(email, password, "", newpassword);
			ui->cloud_storage_new_passwd->setText("");
		}
	} else if (prefs.cloud_verification_status == qPref::CS_UNKNOWN ||
		   prefs.cloud_verification_status == qPref::CS_INCORRECT_USER_PASSWD ||
		   email != prefs.cloud_storage_email ||
		   password != prefs.cloud_storage_password) {

		// different credentials - reset verification status
		int oldVerificationStatus = cloud->cloud_verification_status();
		cloud->set_cloud_verification_status(qPref::CS_UNKNOWN);
		if (!email.isEmpty() && !password.isEmpty()) {
			// connect to backend server to check / create credentials
			QRegularExpression reg("^[[email protected]+_-]+$");
			if (!reg.match(email).hasMatch() || (!password.isEmpty() && !reg.match(password).hasMatch())) {
				report_error(qPrintable(tr("Cloud storage email and password can only consist of letters, numbers, and '.', '-', '_', and '+'.")));
				cloud->set_cloud_verification_status(oldVerificationStatus);
				return;
			}
			CloudStorageAuthenticate *cloudAuth = new CloudStorageAuthenticate(this);
			connect(cloudAuth, &CloudStorageAuthenticate::finishedAuthenticate, this, &PreferencesNetwork::updateCloudAuthenticationState);
			cloudAuth->backend(email, password);
		}
	} else if (prefs.cloud_verification_status == qPref::CS_NEED_TO_VERIFY) {
		QString pin = ui->cloud_storage_pin->text();
		if (!pin.isEmpty()) {
			// connect to backend server to check / create credentials
			QRegularExpression reg("^[[email protected]+_-]+$");
			if (!reg.match(email).hasMatch() || !reg.match(password).hasMatch()) {
				report_error(qPrintable(tr("Cloud storage email and password can only consist of letters, numbers, and '.', '-', '_', and '+'.")));
				return;
			}
			CloudStorageAuthenticate *cloudAuth = new CloudStorageAuthenticate(this);
			connect(cloudAuth, SIGNAL(finishedAuthenticate()), this, SLOT(updateCloudAuthenticationState()));
			cloudAuth->backend(email, password, pin);
		}
	}
	cloud->set_cloud_storage_email(email);
	cloud->set_save_password_local(ui->save_password_local->isChecked());
	cloud->set_cloud_storage_password(password);
	cloud->set_cloud_verification_status(prefs.cloud_verification_status);
	cloud->set_cloud_base_url(prefs.cloud_base_url);
}

void uart_disable_modem_irq(int channel) {
#ifndef QEMU
	volatile int *ctrl = reg(channel, UART_CTLR_OFFSET);
	*ctrl &= ~MSIEN_MASK;
#endif
}