Пример #1
0
BigNum BigNum::operator *(const BigNum& operand) const {
	std::vector<uint32_t> ret(data.size() + operand.data.size() - 1, 0);
	std::vector<uint8_t> u8ret;
	for (int i = 0; i < data.size(); i++)
		for (int j = 0; j < operand.data.size(); j++) {
			//std::cout << "j: " << j << ". operand.data.size(): " << operand.data.size() << std::endl;
			ret[i + j] += (uint16_t) data[i] * operand.data[j];
		}
	uint32_t carry(0);
	for (std::vector<uint32_t>::iterator it = ret.begin(); it != ret.end();
			it++) {
		*it += carry;
		carry = *it >> 8;
		u8ret.push_back((*it) bitand ((1 << 8) - 1));
	}
	while (carry > 0) {
		u8ret.push_back(carry bitand ((1 << 8) - 1));
		carry >>= 8;
	}

	//redudant because u8ret will be refined in BigNum construction but for sake of logical purpose
//	while(not u8ret.empty() and *u8ret.rbegin() == 0)
//		u8ret.pop_back();

	BigNum bb(0);
	bb.data = u8ret;
	bb.negative = negative xor operand.negative;
	bb.refine();
	return bb;
}
Пример #2
0
  Bignum::Bignum(const char * number) {
    init();

    bool symbol = false;
    if (number[0] == '-') {
      number += 1;
      symbol = true;
    }

    int len = strlen(number), tmp_i = 0;
    

    for (int i = bignum_len - 1; len > 0 && i >= 0; i--) {
      tmp_i++;

      if (len >= LONG_LEN) {
        bignum[i] += str_to_int64(number + (len - LONG_LEN), LONG_LEN);

        carry(i);
      } else {
        bignum[i] += str_to_int64(number, len);
        break;
      } 

      len -= LONG_LEN;
    }

    if (symbol) { bignum[bignum_len - tmp_i] *= -1; }
    
  }
Пример #3
0
/*
 * FC 0x01 Read Coil Status respond / FC 0x02 Read Input Status
 */
int tcp_build_resp_read_status(struct tcp_frm_rsp *tx_buf, struct thread_pack *tpack, unsigned char fc)
{
	int byte;
	int txlen;
	unsigned short msglen;
	unsigned short len;   

	len = tpack->tmpara->len;
	byte = carry((int)len, 8);
	txlen = byte + 9;
	msglen = byte + 3;	
	tpack->tsfpara->msglen = msglen;
	tx_buf->transID = htons(tpack->tsfpara->transID);
	tx_buf->potoID = htons(tpack->tsfpara->potoID);
	tx_buf->msglen = htons(tpack->tsfpara->msglen);
	tx_buf->unitID = tpack->tsfpara->unitID;
	tx_buf->fc = fc;
	tx_buf->byte = (unsigned char)byte;

	memset(tx_buf+1, 0, byte);		// tx_buf+1 shift a size of sturct "tcp_frm_rsp" (9 byte)

//	printf("<Modbus TCP Slave> respond Read %s Status\n", fc==READCOILSTATUS?"Coil":"Input");
   
	return txlen;
}
Пример #4
0
void check_carry(void)
{
	/* Check cost of carry for a put  */
	double S = 500.0, X = 490.0, r = 0.08, b = 0.03, v = 0.15, T = 3.0/12;

	assert_equal(carry(0, S, X, T, r, b, v), -42.2254);
	assert_equal(carry_put(S, X, T, r, b, v), -42.2254);
}
 ListNode* sumList(ListNode* A, ListNode* B, int c)
 {
    ListNode* m = nullptr;
	ListNode* t = nullptr;
	ListNode* e = nullptr;
     
    while( (A!=nullptr || B!=nullptr || c!=0) )
    {   
		if(A==nullptr && B==nullptr)
		{
			t = new ListNode(0 + 0);
			carry(c, t->val);
		}
		else if(A==nullptr)
		{
			t = new ListNode(0 + B->val);
			carry(c,t->val);
			B = B->next;
		}
		else if(B==nullptr)
		{
			t = new ListNode(A->val + 0);
			carry(c,t->val);
			A = A->next;
		}
		else 
        {
           t = new ListNode( A->val + B->val) ;
           carry(c,t->val);
		   A = A->next;
		   B = B->next;
        }
		if(m==nullptr)
		{
			m = t;
			e = t;
		}
		else
		{
			e->next = t;
			e = e->next;
		}
        
	}
	return m;
}
Пример #6
0
/*===========================================================================*
 *				do_rdwt					     *
 *===========================================================================*/
static int do_rdwt(int flag_rw)
{
	size_t size, size_ret;
	u64_t pos;
	int r;

	pos = make64(m_in.BDEV_POS_LO, m_in.BDEV_POS_HI);
	size = m_in.BDEV_COUNT;

	if (rem64u(pos, SECTOR_SIZE) != 0 || size % SECTOR_SIZE != 0) {
		printf("Filter: unaligned request from caller!\n");

		return EINVAL;
	}

	buffer = flt_malloc(size, buf_array, BUF_SIZE);

	if(flag_rw == FLT_WRITE)
		carry(size, flag_rw);

	reset_kills();

	for (;;) {
		size_ret = size;
		r = transfer(pos, buffer, &size_ret, flag_rw);
		if(r != RET_REDO)
			break;

#if DEBUG
		printf("Filter: transfer yielded RET_REDO, checking drivers\n");
#endif
		if((r = check_driver(DRIVER_MAIN)) != OK) break;
		if((r = check_driver(DRIVER_BACKUP)) != OK) break;
	}

	if(r == OK && flag_rw == FLT_READ)
		carry(size_ret, flag_rw);

	flt_free(buffer, size, buf_array);

	if (r != OK)
		return r;

	return size_ret;
}
Пример #7
0
/*
	Routine to move an object
*/
void move(int obj, int where)
{
	int	from;

	from = (obj<MAXOBJ) ? place[obj] : fixed[obj];
	if (from>0 && from<=300)
		carry(obj, from);
	drop(obj, where);
}
Пример #8
0
  Bignum::Bignum(const int64 number) {
    init();

    bignum[bignum_len - 1] = number;

    for (int i = bignum_len - 1; i >= 0; i--) {
      if (bignum[i] == 0) { break; }
      carry(i);
    }
  }
Пример #9
0
RCP<const UnivariateIntPolynomial> mul_poly(const UnivariateIntPolynomial &a,
                                            const UnivariateIntPolynomial &b)
{
    RCP<const Symbol> var = symbol("");
    if (a.get_var()->get_name() == "") {
        var = b.get_var();
    } else if (b.get_var()->get_name() == "") {
        var = a.get_var();
    } else if (!(a.get_var()->__eq__(*b.get_var()))) {
        throw std::runtime_error("Error: variables must agree.");
    } else {
        var = a.get_var();
    }

    bool neg = false;

    if ((--(a.get_dict().end()))->second < 0)
        neg = not neg;
    if ((--(b.get_dict().end()))->second < 0)
        neg = not neg;

    unsigned int N
        = bit_length(std::min(a.get_degree() + 1, b.get_degree() + 1))
          + bit_length(a.max_abs_coef()) + bit_length(b.max_abs_coef());

    integer_class a1(1), b1;
    a1 <<= N;
    integer_class a2 = a1 / 2;
    integer_class mask = a1 - 1;
    integer_class a_val(a.eval_bit(N)), b_val(b.eval_bit(N));
    integer_class s_val(a_val * b_val);
    integer_class r = mp_abs(s_val);

    std::vector<integer_class> v;
    integer_class carry(0);

    while (r != 0 or carry != 0) {
        mp_and(b1, r, mask);
        if (b1 < a2) {
            v.push_back(b1 + carry);
            carry = 0;
        } else {
            v.push_back(b1 - a1 + carry);
            carry = 1;
        }
        r >>= N;
    }
    if (neg)
        return neg_poly(*UnivariateIntPolynomial::from_vec(var, v));
    else
        return UnivariateIntPolynomial::from_vec(var, v);
}
Пример #10
0
void
move(int object, int where)
{
	int	from;

	if (object <= 100)
		from = place[object];
	else
		from = fixed[object - 100];
	if (from > 0 && from <= 300)
		carry(object, from);
	drop(object, where);
}
Пример #11
0
literalt bv_utilst::carry_out(
  const bvt &op0,
  const bvt &op1,
  literalt carry_in)
{
  assert(op0.size()==op1.size());

  literalt carry_out=carry_in;

  for(std::size_t i=0; i<op0.size(); i++)
    carry_out=carry(op0[i], op1[i], carry_out);

  return carry_out;
}
Пример #12
0
/* 
 * FC 0x01 Read Coil Status respond / FC 0x02 Read Input Status
 */
int ser_build_resp_read_status(unsigned char *tx_buf, struct frm_para *sfpara, unsigned char fc)
{
	int byte;
	int src_len;
	unsigned char slvID;
	unsigned char src[FRMLEN];
	
	slvID = (unsigned char)sfpara->slvID;
	byte = (int)carry(sfpara->len, 8);
//	printf("<modbus serial slave> respond read %s status\n", fc==READCOILSTATUS?"coil":"input");

	src_len = _build_frame(src, "cccD", slvID, fc, (unsigned char)byte, byte);
	build_rtu_frm(tx_buf, src, src_len);
	src_len += 2;	// CRC 2 byte
	return src_len;
} 
Пример #13
0
vector<int> plusOne(vector<int>& digits) 
{
    if(allNines(digits))
    {
        digits.push_back(0);
        digits[0] = 1;
        for(int i=1;i<digits.size()-1;i++)
        {
            digits[i] = 0;
        }
    }
    else
    {
        digits[digits.size()-1]++;
    }
    carry(digits);
    return digits;   
}
Пример #14
0
void Agent::addCarried(AgentRef a) {
	assert(a);

	// TODO: muh, vehicle drop needs more thought
	if (a->invehicle) {
		Vehicle *v = dynamic_cast<Vehicle *>(a->invehicle.get());
		assert(v);
		v->dropCarried(a);
	}

	carry(a);

	// TODO: this doesn't reorder children or anything..
	a->setZOrder(a->zorder);

	// fire 'Got Carried Agent'
	if (engine.version >= 3)
		queueScript(124, a); // TODO: is this the correct param?
}
Пример #15
0
Integer& Integer::operator*= (Integer b)
{
  Integer result;
  std::vector<bool> vec_a = bits_;
  std::vector<bool> vec_b = b.bits_;
  std::vector<Integer> carry(vec_a.size());
  
  //Using binary method of addition, multiply individually by each digit in multiplier
  for (int i = static_cast<int>(vec_a.size()) - 1; i >= 0; --i)
  {
    //Iterate through multiplicand vector and multiply every digit by current working digit
    for (int m = static_cast<int>(vec_b.size()) - 1; m >= 0; --m)
    {
      //1 and 1 = 1
      //0 and 1 = 0
      //1 and 0 = 0
      carry[i].bits_.insert(carry[i].bits_.begin(), (vec_b[m] && vec_a[i]));
    }
    
    //Add a zero for each 2^k
    for (int l = static_cast<int>(vec_a.size()) - 1; l > i; --l)
    {
      carry[i].bits_.push_back(false);
    }
  }
  
  //Add each individual multiplication operation together into final vector
  for (int i = static_cast<int>(carry.size() - 1); i >= 0; --i)
  {
    result += carry[i];
  }
  
  //Set current vector equal to result
  this->bits_ = result.bits_;
  //std::cout << this->bits_[0];
  return *this;
}
Пример #16
0
        void search() {
            VariableValue left, right;
            std::vector<VariableValue> currentPoint(_meshCentre.size());
            std::vector<double> carry(_variables.size());
            std::vector<window> windows(_variables.size());
            long long nodesInCurrentRow;
            long long nodesPerRow;
            long long numNodes;

            /* set up some "helper" functions. They're not on the class because
             * wtf why would they be there? They're not at all useful to
             * anything else
             */
            auto nodesInRow = [&] (int i) {
                return (_variables[i].getType() == VariableType::Discrete ?
                            std::min(nodesPerRow,
                                _variables[i].rangeEnd.ll - _variables[i].rangeStart.ll + 1ll) :
                            nodesPerRow);
            };
            auto getWindowForVariable = [&] (int idx) {
                nodesInCurrentRow = nodesInRow(idx);
                window w;
                if (_variables[idx].getType() == VariableType::Continuous) {
                    w.left.d = std::max(_variables[idx].rangeStart.d, (double)_meshCentre[idx] - _sideWidth/2.0);
                    w.right.d = std::min(_variables[idx].rangeEnd.d, (double)_meshCentre[idx] + _sideWidth/2.0);
                } else if (_variables[idx].getType() == VariableType::Discrete) {
                    w.left.ll = std::max(_variables[idx].rangeStart.ll, (long long)_meshCentre[idx] - nodesInCurrentRow / 2);
                    w.right.ll = std::min(_variables[idx].rangeEnd.ll, (long long)_meshCentre[idx] + nodesInCurrentRow / 2);
                }
                return w;
            };
            auto incrementVariable = [&](int i) {
                if (_variables[i].getType() == VariableType::Discrete) {
                    currentPoint[i].ll += (long long)((windows[i].right.ll - windows[i].left.ll) / (double) (nodesInCurrentRow - 1));
                    // For discrete vars, add with carry to deal with possible
                    // windows-size problems (right - left > numNodes).
                    // This logic could be horribly horribly f****d.
                    double _ = (double)currentPoint[i].ll;
                    _ += carry[i];
                    // I don't want to round() this, I want to floor + deal with
                    // potential double-precision problems
                    if (floor(_ + EPS) != floor(_)) {
                        carry[i] = 0.0;
                        currentPoint[i].ll = (long long)ceil(_);
                    } else {
                        carry[i] = _ - floor(_);
                        currentPoint[i].ll = (long long)floor(_);
                    }
                } else {
                    currentPoint[i].d += ((windows[i].right.d - windows[i].left.d) / (double) (nodesInCurrentRow - 1));
                }
            };

            for (; ; _constrictions++) {
                std::fill(carry.begin(), carry.end(), 0.0);
                nodesPerRow = pow((1/_constrictFactor), _constrictions) + 1;
                numNodes = 1;

                for (int i = 0; i < _variables.size(); i++) {
                    windows[i] = getWindowForVariable(i);
                    numNodes *= nodesInCurrentRow;
                    currentPoint[i] = windows[i].left;
                }

                std::cout << numNodes << std::endl;

                // This is stupid, but I'm doing it anyway to fix some
                // stupidity:
                VariableValue _ = currentPoint[0];
                nodesInCurrentRow = nodesInRow(0);
                incrementVariable(0);

                // TODO Fix this later
                //if (currentPoint[0] - _ <= _lengthTolerance) return;

                if (_variables[0].getType() == VariableType::Continuous)
                    currentPoint[0].d = _.d - (currentPoint[0].d - _.d);
                else
                    currentPoint[0].ll = _.ll - (currentPoint[0].ll - _.ll);

                for (long long i = 0; i < numNodes; i++) {
                    nodesInCurrentRow = nodesInRow(0);
                    incrementVariable(0);
                    for (int j = 0; j < _variables.size(); j++) {
                        //nodesInCurrentRow = nodesInRow(j); 
                        // TODO hack
                        if ((_variables[j].getType() == VariableType::Continuous && currentPoint[j].d > windows[j].right.d) ||
                            (_variables[j].getType() == VariableType::Discrete && currentPoint[j].ll > windows[j].right.ll)) {
                            currentPoint[j] = windows[j].left;
                            if (j < _variables.size() - 1) {
                                nodesInCurrentRow = nodesInRow(j+1);
                                incrementVariable(j+1);
                            }
                        } else break;
                    }

                    std::cout << "(";
                    for (int j = 0; j < _variables.size(); j++)
                        std::cout << (_variables[j].getType() == VariableType::Discrete ? currentPoint[j].ll : currentPoint[j].d) << (j == _variables.size() - 1 ? "" : ",\t\t");
                    std::cout << ")\n";
                }

            }
        }
Пример #17
0
/*
	CARRY TAKE etc.
*/
vtake()
{
	int msg;
	int i;

	if (toting(object)) {
		actspk(verb);
		return;
	}
	/*
	   special case objects and fixed objects
	*/
	msg = 25;
	if (object == PLANT && prop[PLANT] <= 0)
		msg = 115;
	if (object == BEAR && prop[BEAR] == 1)
		msg = 169;
	if (object == CHAIN && prop[BEAR] != 0)
		msg = 170;
	if (fixed[object]) {
		rspeak(msg);
		return;
	}
	/*
	   special case for liquids
	*/
	if (object == WATER || object == OIL) {
		if (!here(BOTTLE) || liq() != object) {
			object = BOTTLE;
			if (toting(BOTTLE)&&prop[BOTTLE] == 1){
				vfill();
				return;
			}
			if (prop[BOTTLE] != 1)
				msg = 105;
			if (!toting(BOTTLE))
				msg = 104;
			rspeak(msg);
			return;
		}
		object = BOTTLE;
	}
	if (holding >= 7) {
		rspeak(92);
		return;
	}
	/*
	   special case for bird.
	*/
	if (object == BIRD && prop[BIRD] == 0) {
		if (toting(ROD)) {
			rspeak(26);
			return;
		}
		if (!toting(CAGE)) {
			rspeak(27);
			return;
		}
		prop[BIRD] = 1;
	}
	if ( (object == BIRD || object == CAGE) &&
		prop[BIRD] != 0)
		carry((BIRD+CAGE)-object,loc);
	carry(object,loc);
	/*
	   handle liquid in bottle
	*/
	i = liq();
	if (object == BOTTLE && i != 0)
		place[i] = -1;
	rspeak(54);
}
Пример #18
0
// Specialisation for two operands.
    Result
    bvAddBothWays(FixedBits& x, FixedBits& y, FixedBits& output)
    {
      const int bitWidth = output.getWidth();
      FixedBits carry(bitWidth + 1, false);
      carry.setFixed(0, true);
      carry.setValue(0, false);

      //cerr << "input" << x << y << output << endl;

      for (int i = 0; i < bitWidth; i++)
        {
        //cerr << i << ":"<< x[i] << y[i] << carry[i] << "=" << output[i]<< endl;

        int lb = (x[i] == '1' ? 1 : 0) + (y[i] == '1' ? 1 : 0) + (carry[i] == '1' ? 1 : 0);
        int ub = (x[i] == '0' ? 0 : 1) + (y[i] == '0' ? 0 : 1) + (carry[i] == '0' ? 0 : 1);

        const int lb_initial = lb;
        const int ub_initial = ub;

        if (carry[i+1] == '1') // carry out is true.
          lb = std::max(2, lb);

        if (carry[i+1] == '0') // carry out is false.
          ub = std::min(1, ub);

        const char output_i = output[i];
        if (output_i == '1' && (lb % 2 == 0))
          lb++;

        if (output_i == '0' && (lb % 2 == 1))
          lb++;

        if (output_i == '1' && (ub % 2 == 0))
          ub--;

        if (output_i == '0' && (ub % 2 == 1))
          ub--;

        if (lb >= 2)
          setValue(carry, i+1, true);

        if (ub <= 1)
          setValue(carry, i+1, false);

        if (ub < lb)
          return CONFLICT;

        if (lb == ub)
          {
            setValue(output, i, ((lb % 2) == 1));

            if (lb_initial  ==lb)
              {
                if (!x.isFixed(i))
                  setValue(x, i, false);
                if (!y.isFixed(i))
                  setValue(y, i, false);
                if (!carry.isFixed(i))
                  {
                  setValue(carry, i, false);
                  i = std::max(i-2,-1); // go back to the prior column.
                  continue;
                  }
              }

            if (ub_initial ==lb)
              {
                if (!x.isFixed(i))
                  setValue(x, i, true);
                if (!y.isFixed(i))
                  setValue(y, i, true);
                if (!carry.isFixed(i))
                  {
                  setValue(carry, i, true);
                  i = std::max(i-2,-1); // go back to the prior column.
                  continue;
                  }

              }
          }
        //cerr << i << "[" << ub << ":" << lb << "]" << endl;
        }

      return NOT_IMPLEMENTED;
    }
Пример #19
0
/* called by GUI */
Icon::Icon(User *user, void *d)
{
  char *infos = (char *) d;
  ifile = NULL;
  ofile = NULL;
  char *action = NULL;
  vref = NULL;
  char icon[URL_LEN];
  *icon = 0;

  /* parameters transmission */
  for (char *pt = strtok(infos, "&"); pt ; pt = strtok(NULL, "&")) {
    if (! stringcmp(pt, "<url=")) { pt = getParam(pt); strcpy(names.url, pt); taken = true; }
    else if (! stringcmp(pt, "<file=")) { pt = getParam(pt); ifile = strdup(pt); }
    else if (! stringcmp(pt, "<ofile=")) { pt = getParam(pt); strcpy(names.url, pt); }
    else if (! stringcmp(pt, "<name=")) { pt = getParam(pt); strcpy(names.named, pt); }
    else if (! stringcmp(pt, "<icon=")) { pt = getParam(pt); strcpy(icon, pt); }
    else if (! stringcmp(pt, "<action=")) { pt = getParam(pt); action = strdup(pt); }
    else if (! stringcmp(pt, "<vref=")) {
      pt = strchr(pt, '=');
      pt++;
      char *p2;
      if ((p2 = strchr(pt, '>'))) *p2 = 0;
      vref = strdup(pt);
    }
  }

  if (vref) {	// local saved document exists
    parser(vref);

    // get the last loaded texture
    int texid = Texture::getIdByUrl(names.url);
    Texture *tclast = Texture::getEntryById(texid);
    if (! tclast) {
      tex = new char[sizeof(ICO_DEF) + 1];
      strcpy(tex, ICO_DEF);	// default texture
    }
    else {
      tex = new char[strlen(tclast->url) + 1];
      strcpy(tex, tclast->url);
    }
    taken = false;
  }

  else {	// new document named interactively by hand
    /* position */
    float off = 0.4;
    pos.x = user->pos.x + off * Cos(user->pos.az);
    pos.y = user->pos.y + off * Sin(user->pos.az);
    pos.z = user->pos.z + 0.6;        // visible by eyes
    pos.az = user->pos.az + M_PI_2;

    /* texture */
    if (*icon) {
      tex = new char[strlen(icon) + 1];
      strcpy(tex, icon);
    }
    else {
      // default binding icon to document
      char ext[8] = "";
      memset(ext, 0, sizeof(ext));
      if (Format::getExt(names.url, ext)) {
        tex = new char[URL_LEN];
        Format::getImgByExt(ext, tex);
      }
      else {
        tex = new char[sizeof(ICO_DEF) + 1];
        strcpy(tex, ICO_DEF);
      }
    }

    if (ifile) {	// private local document
      if (*names.url) {
        // public url given by user
        Cache::download(ifile, ofile, "inout");
      }
      else {
        // build local ofile in ~/public_html/vreng/
        ofile = new char[URL_LEN];
        sprintf(ofile, "%s/public_html", getenv("HOME"));
        if (access(ofile, R_OK|W_OK|X_OK) == 0) {
          strcat(ofile, "/vreng/");
          if (access(ofile, R_OK|W_OK|X_OK) == -1)
            mkdir(ofile, 0755);
          strcat(ofile, ifile);
          FILE *fin, *fout;
          if ((fin = File::openFile(ifile, "r")) && (fout = File::openFile(ofile, "w"))) {
            char buf[2];
            while (fread(buf, 1, 1, fin))
              fwrite(buf, 1, 1, fout);
            File::closeFile(fin);
            File::closeFile(fout);
            chmod(ofile, 0644);

            //FIXME: define local http_server
            sprintf(names.url, "http://%s/~%s/vreng/%s", DEF_HTTP_SERVER, getenv("USER"), ifile);
          }
          else {
            error("can't open %s or %s: %s (%d)", ifile, ofile, strerror(errno), errno);
            free(ifile); ifile = NULL;
            delete[] ofile;
          }
        }
        else {
          error("can't access %s", ofile);
          free(ifile); ifile = NULL;
          delete[] ofile;
        }
      }
    }
    makeSolid();
  }

  // local creation
  defaults();

  enableBehavior(REMOVABLE);
  enableBehavior(NO_ELEMENTARY_MOVE);
  setRenderPrior(RENDER_HIGH);

  initializeMobileObject(1);
  ttl = (taken) ? MAXFLOAT : 0;
  initImposedMovement(ttl);
  disablePermanentMovement();

  // network creation
  createVolatileNetObject(PROPS);

  // document's owner
  setOwner();

  trace(DBG_WO, "Icon: url=%s icon=%s name=%s owner=%s", urlName(), tex, getInstance(), ownerName());

  if (action) {
    if      (! stringcmp(action, "pin")) pin(this, NULL, 0L, 0L);
    else if (! stringcmp(action, "push")) push(this, NULL, 0L, 0L);
    else if (! stringcmp(action, "carry")) carry(this, NULL, 0L, 0L);
  }
}
Пример #20
0
static void set_para(mbus_cmd_info *cmd)
{
	mb_printf("Enter Slave ID : ");
	scanf("%hhu", &cmd->info.unitID);
	printf("Function code :\n");
	printf("%hhu\t\tRead Coil Status\n", READCOILSTATUS);
	printf("%hhu\t\tRead Input Status\n", READINPUTSTATUS);
	printf("%hhu\t\tRead Holding Registers\n", READHOLDINGREGS);
	printf("%hhu\t\tRead Input Registers\n", READINPUTREGS);
	printf("%hhu\t\tForce Single Coil\n", FORCESINGLECOIL);
	printf("%hhu\t\tPreset Single Register\n", PRESETSINGLEREG);
	printf("%hhu\t\tForce multi Coil\n", FORCEMULTICOILS);
	printf("%hhu\t\tPreset multi Register\n", PRESETMULTIREGS);
	printf("Enter Function code : ");
	scanf("%hhu", &cmd->info.fc);
	switch(cmd->info.fc){
		case READCOILSTATUS:
		case READINPUTSTATUS:
		case READHOLDINGREGS:
		case READINPUTREGS:
			printf("Setting Start addr (start from 0): ");
			scanf("%hu", &cmd->query.addr);
			printf("Setting Data Length: ");
			scanf("%hu", &cmd->query.len);
			break;
		case FORCESINGLECOIL:
			printf("Setting Start addr (start from 0): ");
			scanf("%hu", &cmd->swrite.addr);
			cmd->swrite.data = htobe16(0);
			break;
		case PRESETSINGLEREG:
			printf("Setting Start addr (start from 0): ");
			scanf("%hu", &cmd->swrite.addr);
			cmd->swrite.data = htobe16(0);
			break;
		case FORCEMULTICOILS:
			printf("Setting Start addr (start from 0): ");
			scanf("%hu", &cmd->mwrite.addr);
			printf("Setting Data Length: ");
			scanf("%hu", &cmd->mwrite.len);
			bytecnt = carry(cmd->mwrite.len, 8);
			cmd->mwrite.bcnt = bytecnt;
			wdata = (uint8_t *)malloc(bytecnt);
			assert(wdata);
			memset(wdata, 0, bytecnt);
			cmd->mwrite.data = wdata;
			break;
		case PRESETMULTIREGS:
			printf("Setting Start addr (start from 0): ");
			scanf("%hu", &cmd->mwrite.addr);
			printf("Setting Data Length: ");
			scanf("%hu", &cmd->mwrite.len);
			bytecnt = cmd->mwrite.len * sizeof(short);
			cmd->mwrite.bcnt = bytecnt;
			wdata = (uint8_t *)malloc(bytecnt);
			assert(wdata);
			memset(wdata, 0, bytecnt);
			cmd->mwrite.data = wdata;
			break;
		default:
			printf("unknown function code");
			exit(0);
	}

	printf("Setup delay between each command (seconds): ");
	scanf("%u", &delay);
}
Пример #21
0
void InvocationCounter::print() {
  tty->print_cr("invocation count: up = %d, limit = %d, carry = %s, state = %s",
                                   count(), limit(),
                                   carry() ? "true" : "false",
                                   state_as_string(state()));
}
Пример #22
0
void InvocationCounter::print_short() {
  tty->print(" [%d%s;%s]", count(), carry()?"+carry":"", state_as_short_string(state()));
}
Пример #23
0
/*
 * Analyze modbus TCP respond
 */
int tcp_resp_parser(unsigned char *rx_buf, struct tcp_frm_para *tmfpara, int rlen)
{
//	int i;
	int act_byte;
	unsigned short tmp16;
	unsigned char qfc, rfc;
	unsigned short qact, ract;
	unsigned short qlen;
//	unsigned short raddr;
	unsigned short rrlen;
/*	char *s[EXCPMSGTOTAL] = {"<Modbus TCP Master> Read Coil Status (FC=01) exception !!",
							 "<Modbus TCP Master> Read Input Status (FC=02) exception !!",
							 "<Modbus TCP Master> Read Holding Registers (FC=03) exception !!",
							 "<Modbus TCP Master> Read Input Registers (FC=04) exception !!",
							 "<Modbus TCP Master> Force Single Coil (FC=05) exception !!",
							 "<Modbus TCP Master> Preset Single Register (FC=06) exception !!"
							};
*/	
	qfc = tmfpara->fc;
	rfc = *(rx_buf+7);
	qlen = tmfpara->len;
	rrlen = *(rx_buf+8);
	
	if(qfc != rfc){
		if(rfc > PRESETEXCPSTATUS_EXCP || rfc < READCOILSTATUS_EXCP){
			printf("<Modbus TCP Master> unknown respond function code : %x !!\n", rfc);
			return -1;
		}	
//		printf("%s\n", s[rfc - READCOILSTATUS_EXCP]);	
		return -1;
	}
	
	if(!(rfc ^ READCOILSTATUS) || !(rfc ^ READINPUTSTATUS)){		// fc = 0x01/0x02, detect data len
		act_byte = carry((int)qlen, 8);

		if(rrlen != act_byte){
			printf("<Modbus TCP Master> recv respond length wrong (rlen = %d | qlen = %d)\n", rrlen, act_byte);
			return -1;
		}
/*
		printf("<Modbus TCP Master> Data : ");
		for(i = 9; i < rlen; i++){
			printf(" %x |", *(rx_buf+i));
		}
		printf("\n");
*/
	}else if(!(rfc ^ READHOLDINGREGS) || !(rfc ^ READINPUTREGS)){	// fc = 0x03/0x04, detect data byte
		if(rrlen != qlen << 1){
			printf("<Modbus TCP Master> recv respond byte wrong !!\n");
			return -1;
		}
/*
		printf("<Modbus TCP Master> Data : ");
		for(i = 9; i < rlen; i+=2){
			printf(" %x%x |", *(rx_buf+i), *(rx_buf+i+1));
		}
		printf("\n");
*/
	}else if(!(rfc ^ FORCESIGLEREGS)){								// fc = 0x05, get write on/off status
//		memcpy(&tmp16, rx_buf+8, sizeof(tmp16));
//		raddr = ntohs(tmp16);
		ract = *(rx_buf+10);
		if(ract == 255){
//			printf("<Modbus TCP Master> addr : %x The status to wirte on (FC:0x05)\n", raddr);
		}else if(!ract){
//			printf("<Modbus TCP Master> addr : %x The status to wirte off (FC:0x05)\n", raddr);
		}else{
			printf("<Modbus TCP Master> Unknown status (FC:0x04)\n");
			return -1;
		}
	}else if(!(rfc ^ PRESETEXCPSTATUS)){							// fc = 0x06, get status on register
		qact = tmfpara->act;
		memcpy(&tmp16, rx_buf+8, sizeof(tmp16));
//		raddr = ntohs(tmp16);
		memcpy(&tmp16, rx_buf+10, sizeof(tmp16));
		ract = ntohs(tmp16);
		if(qact != ract){
			printf("<Modbus TCP Master> Action fail (FC:0x06) ");
			printf("Query action : %x | Respond action : %x\n", qact, ract);
			return -1;
		}
//		printf("<Modbus TCP Master> addr : %x Action code : %x\n", raddr, ract);
	}else{															// fc = Unknown 
		printf("<Modbus TCP Master> Unknown Function code %x !!\n", rfc);
		return -1;
	}
	
	return 0;
}
Пример #24
0
literalt bv_utilst::full_adder(
  const literalt a,
  const literalt b,
  const literalt carry_in,
  literalt &carry_out)
{
  #ifdef OPTIMAL_FULL_ADDER
  if(prop.has_set_to() && prop.cnf_handled_well())
  {
    literalt x;
    literalt y;
    int constantProp = -1;

    if(a.is_constant())
    {
      x = b;
      y = carry_in;
      constantProp = (a.is_true()) ? 1 : 0;
    }
    else if(b.is_constant())
    {
      x = a;
      y = carry_in;
      constantProp = (b.is_true()) ? 1 : 0;
    }
    else if(carry_in.is_constant())
    {
      x = a;
      y = b;
      constantProp = (carry_in.is_true()) ? 1 : 0;
    }

    literalt sum;

    // Rely on prop.l* to do further constant propagation
    if(constantProp == 1)
    {
      // At least one input bit is 1
      carry_out = prop.lor(x, y);
      sum = prop.lequal(x, y);
    }
    else if(constantProp == 0)
    {
      // At least one input bit is 0
      carry_out = prop.land(x, y);
      sum = prop.lxor(x, y);
    }
    else
    {
      carry_out = prop.new_variable();
      sum = prop.new_variable();

      // Any two inputs 1 will set the carry_out to 1
      prop.lcnf(!a,        !b, carry_out);
      prop.lcnf(!a, !carry_in, carry_out);
      prop.lcnf(!b, !carry_in, carry_out);

      // Any two inputs 0 will set the carry_out to 0
      prop.lcnf(a,        b, !carry_out);
      prop.lcnf(a, carry_in, !carry_out);
      prop.lcnf(b, carry_in, !carry_out);

      // If both carry out and sum are 1 then all inputs are 1
      prop.lcnf(a, !sum, !carry_out);
      prop.lcnf(b, !sum, !carry_out);
      prop.lcnf(carry_in, !sum, !carry_out);

      // If both carry out and sum are 0 then all inputs are 0
      prop.lcnf(!a, sum, carry_out);
      prop.lcnf(!b, sum, carry_out);
      prop.lcnf(!carry_in, sum, carry_out);

      // If all of the inputs are 1 or all are 0 it sets the sum
      prop.lcnf(!a, !b, !carry_in,  sum);
      prop.lcnf(a,  b,  carry_in, !sum);
    }

    return sum;
  }
  else // NOLINT(readability/braces)
  #endif // OPTIMAL_FULL_ADDER
  {
    // trivial encoding
    carry_out=carry(a, b, carry_in);
    return prop.lxor(prop.lxor(a, b), carry_in);
  }
}
Пример #25
0
/* pick the context menu options appropiate for the item */
int context_menu_object(const object_type *o_ptr)
{
	menu_type *m;
	rect_region r;
	int selected;
	int location = 0;
	char *labels;
	char header[120];
	s16b *list;

	m = menu_dynamic_new();
	if (!m || !o_ptr) {
		return 0;
	}
	object_desc(header, o_ptr, TRUE, 2, sizeof(header));

	list = look_up_list((object_type*)o_ptr);
	if (list) {
		if (list == &(p_ptr->inventory)) {
			location = USE_INVEN;
		} else
		if (list == &(area(p_ptr->px, p_ptr->py)->o_idx)) {
			location = USE_FLOOR;
		} else
		{
			/* check if in a container */
			location = USE_INVEN;
		}
	} else
	if (GET_ARRAY_INDEX(p_ptr->equipment, o_ptr) >= EQUIP_WIELD) {
		location = USE_EQUIP;
	}

	labels = (char*)string_make(lower_case);
	m->selections = labels;

	menu_dynamic_add_label(m, "Inspect", 'I', 1, labels);

	if (item_tester_hook_is_book(o_ptr)) {
		if (player_can_cast_from(o_ptr)) {
			if (player_can_cast()) {
				menu_dynamic_add_label(m, "Cast", 'm', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Cast", 'm', 8, labels);
			}
			if (player_can_study()) {
				menu_dynamic_add_label(m, "Study", 'G', 10, labels);
			} else {
				menu_dynamic_add_label(m, "$Study", 'G', 10, labels);
			}
		}
		if (player_is_caster() && player_can_read()) {
			menu_dynamic_add_label(m, "Browse", 'b', 9, labels);
		}
	} else
	if (item_tester_hook_useable(o_ptr)) {
		if (obj_is_wand(o_ptr)) {
			if (obj_has_charges(o_ptr)) {
				menu_dynamic_add_label(m, "Aim", 'a', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Aim", 'a', 8, labels);
			}
		} else
		if (obj_is_rod(o_ptr)) {
			if (obj_can_zap(o_ptr)) {
				menu_dynamic_add_label(m, "Zap", 'z', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Zap", 'z', 8, labels);
			}
		} else
		if (obj_is_staff(o_ptr)) {
			if (obj_has_charges(o_ptr)) {
				menu_dynamic_add_label(m, "Use", 'u', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Use", 'u', 8, labels);
			}
		} else
		if (obj_is_scroll(o_ptr)) {
			if (player_can_read()) {
				menu_dynamic_add_label(m, "Read", 'r', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Read", 'r', 8, labels);
			}
		} else
		if (obj_is_potion(o_ptr)) {
			menu_dynamic_add_label(m, "Quaff", 'q', 8, labels);
		} else
		if (obj_is_food(o_ptr)) {
			menu_dynamic_add_label(m, "Eat", 'E', 8, labels);
		} else
		if (item_tester_hook_activate(o_ptr)) {
			if (obj_is_activatable(o_ptr)) {
				menu_dynamic_add_label(m, "Activate", 'A', 8, labels);
			} else {
				menu_dynamic_add_label(m, "$Activate", 'A', 8, labels);
			}
		} else
		{
			menu_dynamic_add_label(m, "Use", 'U', 8, labels);
		}
	} else
	if (item_tester_hook_ammo(o_ptr)) {
		if (obj_can_fire(o_ptr)) {
			menu_dynamic_add_label(m, "Fire", 'f', 15, labels);
		} else {
			menu_dynamic_add_label(m, "$Fire", 'f', 15, labels);
		}
	}
	if (obj_can_refill(o_ptr)) {
		menu_dynamic_add_label(m, "Refill", 'F', 11, labels);
	}
	if (item_tester_hook_wear(o_ptr)) {
		if (location == USE_EQUIP) {
			menu_dynamic_add_label(m, "Take off", 't', 3, labels);
		} else
		if (location == USE_INVEN) {
			if (item_tester_hook_armour(o_ptr)) {
				menu_dynamic_add_label(m, "Wear", 'w', 2, labels);
			} else {
		 		menu_dynamic_add_label(m, "Wield", 'w', 2, labels);
			}
			/*menu_dynamic_add_label(m, "Equip", 'w', 2, labels);*/
		}
	}
	if ((location == USE_INVEN) || (location == USE_EQUIP)) {
		menu_dynamic_add_label(m, "Drop", 'd', 6, labels);
		if (o_ptr->number > 1) {
			menu_dynamic_add_label(m, "Drop All", 'd', 13, labels);
		}
	} else
	if (location == USE_FLOOR) {
		if (inven_carry_okay(o_ptr)) {
			menu_dynamic_add_label(m, "Pickup", 'g', 7, labels);
		} else {
			menu_dynamic_add_label(m, "$Pickup", 'g', 7, labels);
		}
	}
	menu_dynamic_add_label(m, "Throw", 'v', 12, labels);

	/*if (obj_has_inscrip(o_ptr)) {*/
	if (o_ptr->inscription) {
		menu_dynamic_add_label(m, "Uninscribe", '}', 5, labels);
	} else {
		menu_dynamic_add_label(m, "Inscribe", '{', 4, labels);
	}
	menu_dynamic_add_label(m, "Destroy", 'k', 14, labels);
#if 0
	if (object_is_squelched(o_ptr)) {
		menu_dynamic_add_label(m, "Unignore", 'k', 14, labels);
	} else {
		menu_dynamic_add_label(m, "Ignore", 'k', 14, labels);
	}
#endif

	/* work out display region */
	r.width = menu_dynamic_longest_entry(m) + 3 + 2; /* +3 for tag, 2 for pad */
	r.col = Term->wid - r.width - 1;
	r.row = 1;
	r.page_rows = m->count;

	/* Hack -- no flush needed */
	msg_flag = FALSE;

	screen_save();
	button_backup_all(TRUE);

	/* Recall object */
	roff_set_width(r.col);
	roff_obj_aux(o_ptr);
	roff_set_width(0);

	menu_layout(m, &r);
	rect_region_erase_bordered(&r);

	prtf(0, 0, "($UEnter to select$Y\n$V, $UESC$Y%c$V) Command for %s:", ESCAPE, header);
	selected = menu_dynamic_select(m);

	menu_dynamic_free(m);
	string_free(labels);

	button_restore();
	screen_load();

	if (selected == 1) {
		/* inspect it */
		identify_fully_aux(o_ptr);
		return 2;
	} else
	if (selected == 2) {
		/* wield the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'w';
		do_cmd_wield();
 		/*cmd_insert(CMD_WIELD);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 3) {
		/* take the item off */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 't';
		do_cmd_takeoff();
 		/*cmd_insert(CMD_TAKEOFF);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 4) {
		/* inscribe the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = '{';
		do_cmd_inscribe();
 		/*cmd_insert(CMD_INSCRIBE);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 5) {
		/* uninscribe the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = '}';
		do_cmd_uninscribe();
 		/*cmd_insert(CMD_UNINSCRIBE);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 6) {
		/* drop the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'd';
		do_cmd_drop();
 		/*cmd_insert(CMD_DROP);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 7) {
		/* pick the item up */
		p_ptr->cmd.cmd = 'g';
		if (inven_carry_okay(o_ptr)) {
			py_pickup_aux((object_type*)o_ptr);
		} else {
			carry(TRUE);
		}
 		/*cmd_insert(CMD_PICKUP);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 8) {
		/* use the item */
		bool full = item_tester_full;
		item_tester_full = FALSE;
		if (player_can_cast_from(o_ptr)) {
			set_get_item_object(o_ptr);
 			p_ptr->cmd.cmd = 'm';
			do_cmd_cast();
		} else {
			set_get_item_object(o_ptr);
			p_ptr->cmd.cmd = 'u';
			repeat_check();
			do_cmd_use();
			/*cmd_insert(CMD_USE_ANY);
			cmd_set_arg_item(cmd_get_top(), 0, slot);*/
		}
		item_tester_full = full;
	} else
	if (selected == 9) {
		/* browse a spellbook */
 		p_ptr->cmd.cmd = 'b';
		do_cmd_browse_aux(o_ptr);
		/* copied from textui_spell_browse */
		/*textui_book_browse(o_ptr);*/
		return 2;
	} else
	if (selected == 10) {
		/* study a spell book */
 		p_ptr->cmd.cmd = 'G';
		do_cmd_study(FALSE, (object_type*)o_ptr);

	} else
	if (selected == 11) {
		/* use the item to refill a light source */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'F';
		do_cmd_refill();
		/*cmd_insert(CMD_REFILL);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 12) {
		/* throw the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'v';
		repeat_check();
		do_cmd_throw();
		/*cmd_insert(CMD_THROW);
		cmd_set_arg_item(cmd_get_top(), 0, slot);*/
	} else
	if (selected == 13) {
		/* drop all of the item stack */
		if (get_check(format("Drop %s? ", header))) {
			set_get_item_object(o_ptr);
			p_ptr->cmd.arg = o_ptr->number;
			p_ptr->cmd.cmd = 'd';
			do_cmd_drop();
			/*cmd_insert(CMD_DROP);
			cmd_set_arg_item(cmd_get_top(), 0, slot);
			cmd_set_arg_number(cmd_get_top(), 1, o_ptr->number);*/
		}
	} else
	if (selected == 14) {
		/* squelch or unsquelch the item */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'k';
		do_cmd_destroy();
		/*textui_cmd_destroy_menu(slot);*/
	} else
	if (selected == 15) {
		/* fire some ammo */
		set_get_item_object(o_ptr);
 		p_ptr->cmd.cmd = 'f';
		repeat_check();
		do_cmd_fire();
	} else
	if (selected == -1) {
		/* this menu was canceled, tell whatever called us to display its menu again */
		return 3;
	}
	return 1;
}
Пример #26
0
int context_menu_player(int mx, int my)
{
	menu_type *m;
	rect_region r;
	int selected;
	char *labels;

	cave_type *c_ptr = area(p_ptr->px,p_ptr->py);
	pcave_type *pc_ptr = parea(p_ptr->px,p_ptr->py);
	feature_type *feat;

	m = menu_dynamic_new();
	if (!m) {
		return 0;
	}

	labels = (char*)string_make(lower_case);
	m->selections = labels;

	feat  = &(f_info[c_ptr->feat]);

	menu_dynamic_add_label(m, "Use Item", 'u', 1, labels);
	/* if player can cast, add casting option */
	if (player_is_caster()) {
		if (player_can_cast()) {
			menu_dynamic_add_label(m, "Cast", 'm', 2, labels);
		} else {
			menu_dynamic_add_label(m, "$Cast", 'm', 2, labels);
		}
	}
	/* if player can use racial powers or mutations, add option */
	if (player_has_power()) {
		if (player_can_use_power()) {
			menu_dynamic_add_label(m, "Use Power", 'U', 16, labels);
		} else {
			menu_dynamic_add_label(m, "$Use Power", 'U', 16, labels);
		}
	}
	/* if player is on stairs add option to use them */
	if (feat->flags & FF_EXIT_UP) {
		menu_dynamic_add_label(m, "Go Up", '<', 11, labels);
	}
	if (feat->flags & FF_EXIT_DOWN) {
		menu_dynamic_add_label(m, "Go Down", '>', 12, labels);
	}
	menu_dynamic_add_label(m, "Search", 's', 3, labels);
	menu_dynamic_add_label(m, "Look", 'l', 6, labels);
	menu_dynamic_add_label(m, "Rest", 'R', 4, labels);
	menu_dynamic_add_label(m, "Inventory", 'i', 5, labels);
	/* if object under player add pickup option */
	if (c_ptr->o_idx) {
		object_type *o_ptr = &(o_list[c_ptr->o_idx]);
		//if (!squelch_item_ok(o_ptr)) {
  			menu_dynamic_add_label(m, "Floor", 'i', 13, labels);
			if (inven_carry_okay(o_ptr)) {
  				menu_dynamic_add_label(m, "Pickup", 'g', 14, labels);
			} else {
  				menu_dynamic_add_label(m, "$Pickup", 'g', 14, labels);
			}
		//}
	}
	menu_dynamic_add_label(m, "Character", 'C', 7, labels);
	/* XXX Don't show the keymap line until the keymap list is implemented, to
	 * avoid confusion as to what should be there */
	/*menu_dynamic_add(m, "Keymaps", 10);*/
	if (!OPT(center_player)) {
		menu_dynamic_add_label(m, "^Center Map", 'L', 15, labels);
	}
	menu_dynamic_add_label(m, "Other", ' ', 9, labels);

	/* work out display region */
	r.width = menu_dynamic_longest_entry(m) + 3 + 2; /* +3 for tag, 2 for pad */
	if (mx > Term->wid - r.width - 1) {
		r.col = Term->wid - r.width - 1;
	} else {
		r.col = mx + 1;
	}
	r.page_rows = m->count;
	if (my > Term->hgt - r.page_rows - 1) {
		if (my - r.page_rows - 1 <= 0) {
			/* menu has too many items, so put in upper right corner */
			r.row = 1;
			r.col = Term->wid - r.width - 1;
		} else {
			r.row = Term->hgt - r.page_rows - 1;
		}
	} else {
		r.row = my + 1;
	}

	/* Hack -- no flush needed */
	msg_flag = FALSE;

	screen_save();
	button_backup_all(TRUE);

	menu_layout(m, &r);
	rect_region_erase_bordered(&r);

	prtf(0, 0, "($UEnter to select$Y\n$V, $UESC$Y%c$V) Command:", ESCAPE);
	selected = menu_dynamic_select(m);

	menu_dynamic_free(m);
	string_free(labels);

	button_restore();
	screen_load();

	switch(selected) {
	case 1:
		{
			/* use an item */
			p_ptr->cmd.cmd = 'u';
			repeat_check();
			do_cmd_use();
		} break;
	case 2:
		{
			/* Cast a spell */
			p_ptr->cmd.cmd = 'm';
			repeat_check();
			do_cmd_cast_wrapper();
		} break;
	case 3:
		{
			/* search */
			p_ptr->cmd.cmd = 's';
			repeat_check();
			do_cmd_search();
		} break;
	case 4:
		{
			/* rest */
			p_ptr->cmd.cmd = 'R';
			repeat_check();
			do_cmd_rest();
		} break;
	case 5:
		{
			/* show inventory screen */
			Term_keypress('i');//,0);
		} break;
	case 6:
		{
			/* look mode */
			if (target_set(TARGET_LOOK)) {
			//if (target_set_interactive(TARGET_LOOK, p_ptr->px, p_ptr->py)) {
				msgf("Target Selected.");
			}
		} break;
	case 7:
		{
			/* show character screen */
			do_cmd_character();
		} break;
	case 9:
		{
			/* show another layer of menu options screen */
			int res;
			while ((res = context_menu_player_2(mx,my)) == 3);
			if (res == 2) return 3;
		} break;
	case 10:
		{
			/* show the commands */
			int res;
			while ((res = context_menu_command(mx,my)) == 3);
			if (res == 2) return 3;
		} break;
	case 11:
		{
			/* go up stairs */
			p_ptr->cmd.cmd = '<';
			repeat_check();
			do_cmd_go_up();
		} break;
	case 12:
		{
			/* go down stairs */
			p_ptr->cmd.cmd = '>';
			repeat_check();
			do_cmd_go_down();
		} break;
	case 13:
		{
			if (c_ptr->o_idx) {
				object_type *o_ptr = &(o_list[c_ptr->o_idx]);
				/* there is an item on the floor, show the inventory screen starting
				 * from the floor */
				if (o_ptr->next_o_idx) {
					do_cmd_inven_floor();
				} else {
					/* if  we only have one item, show the context menu directly */
					if (o_ptr->k_idx) {
						/* Track the object kind */
						object_kind_track(o_ptr->k_idx);

						while (context_menu_object(o_ptr) == 2);
					}
				}
			}
		} break;
	case 14:
		{
			/* pick the item up */
			//cmd_insert(CMD_PICKUP);
			//cmd_set_arg_item(cmd_get_top(), 0, -1);
			carry(TRUE);
		} break;
	case 15:
		{
			/* center the map on the player */
			/*panel_center(p_ptr->px, p_ptr->py);*/
			do_cmd_center_map();
		} break;
	case 16:
		{
			/* use character powers */
			p_ptr->cmd.cmd = 'U';
			repeat_check();
			do_cmd_racial_power();
		} break;

	}

	return 1;
}
Пример #27
0
int ser_resp_parser(unsigned char *rx_buf, struct frm_para *mfpara, int rlen)
{
//	int i;
	unsigned int act_byte;
	unsigned char qfc;
	unsigned int qact;
	unsigned int qlen;
//	unsigned int raddr;
	unsigned char rfc;
	unsigned int rrlen;
	unsigned int ract;
/*	char *s[EXCPMSGTOTAL] = {
		"<Modbus Serial Master> Read Coil Status (FC=01) exception !!",
		"<Modbus Serial Master> Read Input Status (FC=02) exception !!",
		"<Modbus Serial Master> Read Holding Registers (FC=03) exception !!",
		"<Modbus Serial Master> Read Input Registers (FC=04) exception !!",
		"<Modbus Serial Master> Force Single Coil (FC=05) exception !!",
		"<Modbus Serial Master> Preset Single Register (FC=06) exception !!"
	};
*/	
	qfc = mfpara->fc;
	qlen = mfpara->len;	
	rfc = *(rx_buf+1);
	rrlen = *(rx_buf+2);

	if(qfc ^ rfc){
		if(rfc > PRESETEXCPSTATUS_EXCP || rfc < READCOILSTATUS_EXCP){   
			printf("<Modbus Serial Master> Uknow respond function code : %x !!\n", rfc);
			return -1;
        }	
	//	printf("%s\n", s[rfc-READCOILSTATUS_EXCP]);
		return -1;
	}

	if(!(rfc ^ READCOILSTATUS) || !(rfc ^ READINPUTSTATUS)){	// fc = 0x01/0x02, get data len
		act_byte = carry((int)qlen, 8);

		if(rrlen != act_byte){
			printf("<Modbus Serial Master> length fault !!\n");
			return -1;
		}
/*		printf("<Modbus Serial Master> Data :");
		for(i = 3; i < rlen-2; i++){
			printf(" %x |", *(rx_buf+i));
		}
		printf("\n");
*/
	}else if(!(rfc ^ READHOLDINGREGS) || !(rfc ^ READINPUTREGS)){	//fc = 0x03/0x04, get data byte
		if(rrlen != qlen<<1){
			printf("<Modbus Serial Master> byte fault !!\n");
			return -1;
		}
/*
		printf("<Modbus Serial Master> Data : ");
		for(i = 3; i < rlen-2; i+=2){
			printf(" %x%x", *(rx_buf+i), *(rx_buf+i+1));
			printf("|");
		}
		printf("\n");
*/
	}else if(!(rfc ^ FORCESIGLEREGS)){		//fc = 0x05, get action
		ract = *(rx_buf+4);
//		raddr = *(rx_buf+2)<<8 | *(rx_buf+3);
		if(ract == 255){
//			printf("<Modbus Serial Master> addr : %x The status to wirte on (FC:0x05)\n", raddr);
		}else if(!ract){
//			printf("<Modbus Serial Master> addr : %x The status to wirte off (FC:0x05)\n", raddr);
		}else{
			printf("<Modbus Serial Master> Unknow action !!\n");
			return -1;
		}
	}else if(!(rfc ^ PRESETEXCPSTATUS)){	// fc = 0x06, get action
		qact = mfpara->act;
//		raddr = *(rx_buf+2)<<8 | *(rx_buf+3);
		ract = *(rx_buf+4)<<8 | *(rx_buf+5);
		if(qact != ract){
			printf("<Modbus Serial Master> Action wrong !!\n");
			return -1;
		}
//		printf("<Modbus Serial Master> addr : %x Action code = %x\n", raddr, ract);
	}else{
		printf("<Modbus Serial Master> Unknow respond function code = %x\n", rfc);
		return -1;
	}
	
	return 0;
}