Beispiel #1
0
/* 
** RIOParam is used to open or configure a port. You pass it a PortP,
** which will have a tty struct attached to it. You also pass a command,
** either OPEN or CONFIG. The port's setup is taken from the t_ fields
** of the tty struct inside the PortP, and the port is either opened
** or re-configured. You must also tell RIOParam if the device is a modem
** device or not (i.e. top bit of minor number set or clear - take special
** care when deciding on this!).
** RIOParam neither flushes nor waits for drain, and is NOT preemptive.
**
** RIOParam assumes it will be called at splrio(), and also assumes
** that CookMode is set correctly in the port structure.
**
** NB. for MPX
**	tty lock must NOT have been previously acquired.
*/
int RIOParam(struct Port *PortP, int cmd, int Modem, int SleepFlag)
{
	struct tty_struct *TtyP;
	int retval;
	struct phb_param __iomem *phb_param_ptr;
	struct PKT __iomem *PacketP;
	int res;
	u8 Cor1 = 0, Cor2 = 0, Cor4 = 0, Cor5 = 0;
	u8 TxXon = 0, TxXoff = 0, RxXon = 0, RxXoff = 0;
	u8 LNext = 0, TxBaud = 0, RxBaud = 0;
	int retries = 0xff;
	unsigned long flags;

	func_enter();

	TtyP = PortP->gs.tty;

	rio_dprintk(RIO_DEBUG_PARAM, "RIOParam: Port:%d cmd:%d Modem:%d SleepFlag:%d Mapped: %d, tty=%p\n", PortP->PortNum, cmd, Modem, SleepFlag, PortP->Mapped, TtyP);

	if (!TtyP) {
		rio_dprintk(RIO_DEBUG_PARAM, "Can't call rioparam with null tty.\n");

		func_exit();

		return RIO_FAIL;
	}
	rio_spin_lock_irqsave(&PortP->portSem, flags);

	if (cmd == RIOC_OPEN) {
		/*
		 ** If the port is set to store or lock the parameters, and it is
		 ** paramed with OPEN, we want to restore the saved port termio, but
		 ** only if StoredTermio has been saved, i.e. NOT 1st open after reboot.
		 */
	}

	/*
	 ** wait for space
	 */
	while (!(res = can_add_transmit(&PacketP, PortP)) || (PortP->InUse != NOT_INUSE)) {
		if (retries-- <= 0) {
			break;
		}
		if (PortP->InUse != NOT_INUSE) {
			rio_dprintk(RIO_DEBUG_PARAM, "Port IN_USE for pre-emptive command\n");
		}

		if (!res) {
			rio_dprintk(RIO_DEBUG_PARAM, "Port has no space on transmit queue\n");
		}

		if (SleepFlag != OK_TO_SLEEP) {
			rio_spin_unlock_irqrestore(&PortP->portSem, flags);
			func_exit();

			return RIO_FAIL;
		}

		rio_dprintk(RIO_DEBUG_PARAM, "wait for can_add_transmit\n");
		rio_spin_unlock_irqrestore(&PortP->portSem, flags);
		retval = RIODelay(PortP, HUNDRED_MS);
		rio_spin_lock_irqsave(&PortP->portSem, flags);
		if (retval == RIO_FAIL) {
			rio_dprintk(RIO_DEBUG_PARAM, "wait for can_add_transmit broken by signal\n");
			rio_spin_unlock_irqrestore(&PortP->portSem, flags);
			func_exit();
			return -EINTR;
		}
		if (PortP->State & RIO_DELETED) {
			rio_spin_unlock_irqrestore(&PortP->portSem, flags);
			func_exit();
			return 0;
		}
	}

	if (!res) {
		rio_spin_unlock_irqrestore(&PortP->portSem, flags);
		func_exit();

		return RIO_FAIL;
	}

	rio_dprintk(RIO_DEBUG_PARAM, "can_add_transmit() returns %x\n", res);
	rio_dprintk(RIO_DEBUG_PARAM, "Packet is %p\n", PacketP);

	phb_param_ptr = (struct phb_param __iomem *) PacketP->data;


	switch (TtyP->termios->c_cflag & CSIZE) {
	case CS5:
		{
			rio_dprintk(RIO_DEBUG_PARAM, "5 bit data\n");
			Cor1 |= RIOC_COR1_5BITS;
			break;
		}
	case CS6:
		{
			rio_dprintk(RIO_DEBUG_PARAM, "6 bit data\n");
			Cor1 |= RIOC_COR1_6BITS;
			break;
		}
	case CS7:
		{
			rio_dprintk(RIO_DEBUG_PARAM, "7 bit data\n");
			Cor1 |= RIOC_COR1_7BITS;
			break;
		}
	case CS8:
		{
			rio_dprintk(RIO_DEBUG_PARAM, "8 bit data\n");
			Cor1 |= RIOC_COR1_8BITS;
			break;
		}
	}

	if (TtyP->termios->c_cflag & CSTOPB) {
		rio_dprintk(RIO_DEBUG_PARAM, "2 stop bits\n");
		Cor1 |= RIOC_COR1_2STOP;
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "1 stop bit\n");
		Cor1 |= RIOC_COR1_1STOP;
	}

	if (TtyP->termios->c_cflag & PARENB) {
		rio_dprintk(RIO_DEBUG_PARAM, "Enable parity\n");
		Cor1 |= RIOC_COR1_NORMAL;
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "Disable parity\n");
		Cor1 |= RIOC_COR1_NOP;
	}
	if (TtyP->termios->c_cflag & PARODD) {
		rio_dprintk(RIO_DEBUG_PARAM, "Odd parity\n");
		Cor1 |= RIOC_COR1_ODD;
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "Even parity\n");
		Cor1 |= RIOC_COR1_EVEN;
	}

	/*
	 ** COR 2
	 */
	if (TtyP->termios->c_iflag & IXON) {
		rio_dprintk(RIO_DEBUG_PARAM, "Enable start/stop output control\n");
		Cor2 |= RIOC_COR2_IXON;
	} else {
		if (PortP->Config & RIO_IXON) {
			rio_dprintk(RIO_DEBUG_PARAM, "Force enable start/stop output control\n");
			Cor2 |= RIOC_COR2_IXON;
		} else
			rio_dprintk(RIO_DEBUG_PARAM, "IXON has been disabled.\n");
	}

	if (TtyP->termios->c_iflag & IXANY) {
		if (PortP->Config & RIO_IXANY) {
			rio_dprintk(RIO_DEBUG_PARAM, "Enable any key to restart output\n");
			Cor2 |= RIOC_COR2_IXANY;
		} else
			rio_dprintk(RIO_DEBUG_PARAM, "IXANY has been disabled due to sanity reasons.\n");
	}

	if (TtyP->termios->c_iflag & IXOFF) {
		rio_dprintk(RIO_DEBUG_PARAM, "Enable start/stop input control 2\n");
		Cor2 |= RIOC_COR2_IXOFF;
	}

	if (TtyP->termios->c_cflag & HUPCL) {
		rio_dprintk(RIO_DEBUG_PARAM, "Hangup on last close\n");
		Cor2 |= RIOC_COR2_HUPCL;
	}

	if (C_CRTSCTS(TtyP)) {
		rio_dprintk(RIO_DEBUG_PARAM, "Rx hardware flow control enabled\n");
		Cor2 |= RIOC_COR2_CTSFLOW;
		Cor2 |= RIOC_COR2_RTSFLOW;
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "Rx hardware flow control disabled\n");
		Cor2 &= ~RIOC_COR2_CTSFLOW;
		Cor2 &= ~RIOC_COR2_RTSFLOW;
	}


	if (TtyP->termios->c_cflag & CLOCAL) {
		rio_dprintk(RIO_DEBUG_PARAM, "Local line\n");
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "Possible Modem line\n");
	}

	/*
	 ** COR 4 (there is no COR 3)
	 */
	if (TtyP->termios->c_iflag & IGNBRK) {
		rio_dprintk(RIO_DEBUG_PARAM, "Ignore break condition\n");
		Cor4 |= RIOC_COR4_IGNBRK;
	}
	if (!(TtyP->termios->c_iflag & BRKINT)) {
		rio_dprintk(RIO_DEBUG_PARAM, "Break generates NULL condition\n");
		Cor4 |= RIOC_COR4_NBRKINT;
	} else {
		rio_dprintk(RIO_DEBUG_PARAM, "Interrupt on	break condition\n");
	}

	if (TtyP->termios->c_iflag & INLCR) {
		rio_dprintk(RIO_DEBUG_PARAM, "Map newline to carriage return on input\n");
		Cor4 |= RIOC_COR4_INLCR;
	}

	if (TtyP->termios->c_iflag & IGNCR) {
		rio_dprintk(RIO_DEBUG_PARAM, "Ignore carriage return on input\n");
		Cor4 |= RIOC_COR4_IGNCR;
	}

	if (TtyP->termios->c_iflag & ICRNL) {
		rio_dprintk(RIO_DEBUG_PARAM, "Map carriage return to newline on input\n");
		Cor4 |= RIOC_COR4_ICRNL;
	}
	if (TtyP->termios->c_iflag & IGNPAR) {
		rio_dprintk(RIO_DEBUG_PARAM, "Ignore characters with parity errors\n");
		Cor4 |= RIOC_COR4_IGNPAR;
	}
	if (TtyP->termios->c_iflag & PARMRK) {
		rio_dprintk(RIO_DEBUG_PARAM, "Mark parity errors\n");
		Cor4 |= RIOC_COR4_PARMRK;
	}

	/*
	 ** Set the RAISEMOD flag to ensure that the modem lines are raised
	 ** on reception of a config packet.
	 ** The download code handles the zero baud condition.
	 */
	Cor4 |= RIOC_COR4_RAISEMOD;

	/*
	 ** COR 5
	 */

	Cor5 = RIOC_COR5_CMOE;

	/*
	 ** Set to monitor tbusy/tstop (or not).
	 */

	if (PortP->MonitorTstate)
		Cor5 |= RIOC_COR5_TSTATE_ON;
	else
		Cor5 |= RIOC_COR5_TSTATE_OFF;

	/*
	 ** Could set LNE here if you wanted LNext processing. SVR4 will use it.
	 */
	if (TtyP->termios->c_iflag & ISTRIP) {
		rio_dprintk(RIO_DEBUG_PARAM, "Strip input characters\n");
		if (!(PortP->State & RIO_TRIAD_MODE)) {
			Cor5 |= RIOC_COR5_ISTRIP;
		}
	}

	if (TtyP->termios->c_oflag & ONLCR) {
		rio_dprintk(RIO_DEBUG_PARAM, "Map newline to carriage-return, newline on output\n");
		if (PortP->CookMode == COOK_MEDIUM)
			Cor5 |= RIOC_COR5_ONLCR;
	}
	if (TtyP->termios->c_oflag & OCRNL) {
		rio_dprintk(RIO_DEBUG_PARAM, "Map carriage return to newline on output\n");
		if (PortP->CookMode == COOK_MEDIUM)
			Cor5 |= RIOC_COR5_OCRNL;
	}
	if ((TtyP->termios->c_oflag & TABDLY) == TAB3) {
		rio_dprintk(RIO_DEBUG_PARAM, "Tab delay 3 set\n");
		if (PortP->CookMode == COOK_MEDIUM)
			Cor5 |= RIOC_COR5_TAB3;
	}

	/*
	 ** Flow control bytes.
	 */
	TxXon = TtyP->termios->c_cc[VSTART];
	TxXoff = TtyP->termios->c_cc[VSTOP];
	RxXon = TtyP->termios->c_cc[VSTART];
	RxXoff = TtyP->termios->c_cc[VSTOP];
	/*
	 ** LNEXT byte
	 */
	LNext = 0;

	/*
	 ** Baud rate bytes
	 */
	rio_dprintk(RIO_DEBUG_PARAM, "Mapping of rx/tx baud %x (%x)\n", TtyP->termios->c_cflag, CBAUD);

	switch (TtyP->termios->c_cflag & CBAUD) {
#define e(b) case B ## b : RxBaud = TxBaud = RIO_B ## b ;break
		e(50);
		e(75);
		e(110);
		e(134);
		e(150);
		e(200);
		e(300);
		e(600);
		e(1200);
		e(1800);
		e(2400);
		e(4800);
		e(9600);
		e(19200);
		e(38400);
		e(57600);
		e(115200);	/* e(230400);e(460800); e(921600);  */
	}

	rio_dprintk(RIO_DEBUG_PARAM, "tx baud 0x%x, rx baud 0x%x\n", TxBaud, RxBaud);


	/*
	 ** Leftovers
	 */
	if (TtyP->termios->c_cflag & CREAD)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable receiver\n");
#ifdef RCV1EN
	if (TtyP->termios->c_cflag & RCV1EN)
		rio_dprintk(RIO_DEBUG_PARAM, "RCV1EN (?)\n");
#endif
#ifdef XMT1EN
	if (TtyP->termios->c_cflag & XMT1EN)
		rio_dprintk(RIO_DEBUG_PARAM, "XMT1EN (?)\n");
#endif
	if (TtyP->termios->c_lflag & ISIG)
		rio_dprintk(RIO_DEBUG_PARAM, "Input character signal generating enabled\n");
	if (TtyP->termios->c_lflag & ICANON)
		rio_dprintk(RIO_DEBUG_PARAM, "Canonical input: erase and kill enabled\n");
	if (TtyP->termios->c_lflag & XCASE)
		rio_dprintk(RIO_DEBUG_PARAM, "Canonical upper/lower presentation\n");
	if (TtyP->termios->c_lflag & ECHO)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable input echo\n");
	if (TtyP->termios->c_lflag & ECHOE)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable echo erase\n");
	if (TtyP->termios->c_lflag & ECHOK)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable echo kill\n");
	if (TtyP->termios->c_lflag & ECHONL)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable echo newline\n");
	if (TtyP->termios->c_lflag & NOFLSH)
		rio_dprintk(RIO_DEBUG_PARAM, "Disable flush after interrupt or quit\n");
#ifdef TOSTOP
	if (TtyP->termios->c_lflag & TOSTOP)
		rio_dprintk(RIO_DEBUG_PARAM, "Send SIGTTOU for background output\n");
#endif
#ifdef XCLUDE
	if (TtyP->termios->c_lflag & XCLUDE)
		rio_dprintk(RIO_DEBUG_PARAM, "Exclusive use of this line\n");
#endif
	if (TtyP->termios->c_iflag & IUCLC)
		rio_dprintk(RIO_DEBUG_PARAM, "Map uppercase to lowercase on input\n");
	if (TtyP->termios->c_oflag & OPOST)
		rio_dprintk(RIO_DEBUG_PARAM, "Enable output post-processing\n");
	if (TtyP->termios->c_oflag & OLCUC)
		rio_dprintk(RIO_DEBUG_PARAM, "Map lowercase to uppercase on output\n");
	if (TtyP->termios->c_oflag & ONOCR)
		rio_dprintk(RIO_DEBUG_PARAM, "No carriage return output at column 0\n");
	if (TtyP->termios->c_oflag & ONLRET)
		rio_dprintk(RIO_DEBUG_PARAM, "Newline performs carriage return function\n");
	if (TtyP->termios->c_oflag & OFILL)
		rio_dprintk(RIO_DEBUG_PARAM, "Use fill characters for delay\n");
	if (TtyP->termios->c_oflag & OFDEL)
		rio_dprintk(RIO_DEBUG_PARAM, "Fill character is DEL\n");
	if (TtyP->termios->c_oflag & NLDLY)
		rio_dprintk(RIO_DEBUG_PARAM, "Newline delay set\n");
	if (TtyP->termios->c_oflag & CRDLY)
		rio_dprintk(RIO_DEBUG_PARAM, "Carriage return delay set\n");
	if (TtyP->termios->c_oflag & TABDLY)
		rio_dprintk(RIO_DEBUG_PARAM, "Tab delay set\n");
	/*
	 ** These things are kind of useful in a later life!
	 */
	PortP->Cor2Copy = Cor2;

	if (PortP->State & RIO_DELETED) {
		rio_spin_unlock_irqrestore(&PortP->portSem, flags);
		func_exit();

		return RIO_FAIL;
	}

	/*
	 ** Actually write the info into the packet to be sent
	 */
	writeb(cmd, &phb_param_ptr->Cmd);
	writeb(Cor1, &phb_param_ptr->Cor1);
	writeb(Cor2, &phb_param_ptr->Cor2);
	writeb(Cor4, &phb_param_ptr->Cor4);
	writeb(Cor5, &phb_param_ptr->Cor5);
	writeb(TxXon, &phb_param_ptr->TxXon);
	writeb(RxXon, &phb_param_ptr->RxXon);
	writeb(TxXoff, &phb_param_ptr->TxXoff);
	writeb(RxXoff, &phb_param_ptr->RxXoff);
	writeb(LNext, &phb_param_ptr->LNext);
	writeb(TxBaud, &phb_param_ptr->TxBaud);
	writeb(RxBaud, &phb_param_ptr->RxBaud);

	/*
	 ** Set the length/command field
	 */
	writeb(12 | PKT_CMD_BIT, &PacketP->len);

	/*
	 ** The packet is formed - now, whack it off
	 ** to its final destination:
	 */
	add_transmit(PortP);
	/*
	 ** Count characters transmitted for port statistics reporting
	 */
	if (PortP->statsGather)
		PortP->txchars += 12;

	rio_spin_unlock_irqrestore(&PortP->portSem, flags);

	rio_dprintk(RIO_DEBUG_PARAM, "add_transmit returned.\n");
	/*
	 ** job done.
	 */
	func_exit();

	return 0;
}
Beispiel #2
0
int main() {
    /*
    Exceptions can jump out of functions.

    This is their main reason for existing!
    */
    {
        try {
            exception_func_int();
        } catch (int i) {
            assert(i == 1);
        }
    }

    /*
    # std::exception

        Anything can be thrown, including classes and base types.

        All stdlib exceptions inherit from `exception`, so it is a good idea to only throw
        things inherited from it.

        `std::exception` has limited use since its constructor does not take any arguments,
        so you cannot describe the error. Some stdlib derived class constructors do however.
    */
    {
        try {
            throw std::exception();
        } catch (std::exception e) {
        }
    }

    /*
    Catch blocks work like function overloads and catch by type.
    */
    try {
        throw 'c';
    } catch (int i) {
        assert(false);
    } catch (char c) {
    }

    /*
    `...` is the default case
    */
    try {
        throw 1.0;
    } catch (int i) {
        assert(false);
    } catch (char c) {
        assert(false);
    } catch (...) {
    }

    /*
    Derived classes.

    Just like for function overloading, base classes catch for derived classes.
    */
    {
        try {
            throw myexception();
        } catch (std::exception& ex) {
        }
        /*
        This compiles, but generates a warning, since the first catch will always catch instead of this one.
        */
        //catch (myexception& ex)       {assert(false);}
        catch (...)                     {assert(false);}

        /*
        this is a more common exception ordering, first derived then base.
        */
        {
            try {
                throw myexception();
            } catch (myexception& ex) {
            } catch (std::exception& ex) {
                assert(false);
            } catch (...) {
                assert(false);
            }
        }
    }

    /*
    # what

        Returns a string which contains information about the exception.

        Many stdlib exceptions simply return the error message given on the constructor.
    */
    {
        std::string msg = "custom message";
        std::ios_base::failure e(msg);
        // TODO worked in GCC 4.8, failed in GCC 5.1.
        //assert(e.what() == msg);
    }

    /*
    # uncaught exceptions

        Uncaught exceptions explose at top level and terminate the program.

        Check out the error messages generated by each exception.

        Classes that derive from exception and implement `what()` can print custom messages,
        which may contain useful debug info. This is a major point in favor of using exception
        classes instead of base types.
    */
    {
        //throw 1;
        //throw 'c';
        //throw 1.0;
        //throw myexception();
    }

    /*
    # exception specifications

        Functions can specify which exceptions are catchable with the following syntax.
    */
    {
        try {
            exception_func_int_only(true);
        } catch (int i) {
        } catch (...) {
            assert(false);
        }

        try {
            //exception_func_int_only(false);
        } catch (...) {
            /* not even ... this can catch non int exceptions thrown by this function */
        }

        try {
            exception_func_int_exception_only(1);
        } catch (int i) {
        } catch (myexception& ex) {
        } catch (...) {
            assert(false);
        }

        try {
            //exception_func_none();
        } catch (...) {
            /* no exception thrown by this function is catchable */
        }

        try {
            //exception_func_none_wrapper();
        } catch (...) {
            /* the same goes if we wrap the function */
        }
    }

    /*
    # exception from destructor

        Never throw an exception from a destructor.

        Destructors are meant to clean up after exceptions, so if you throw exceptions from them,
        things get messy.

        C++ specifies that if this happens during stack unwinding, the program may terminate!

        What to do to avoid that: <http://stackoverflow.com/questions/130117/throwing-exceptions-out-of-a-destructor>

        The following code could lead to that.
    */
    if (0) {
        try {
            ExceptionDestructor e;
        } catch (...) {
        }

        try {
            ExceptionDestructorCaller();
        } catch (...) {
        }
    }

#if __cplusplus >= 201103L
    /*
    # noexcept

        Improved version of `throw` for functions.

        `throw` for functions becomes deprecated in C++11.

        TODO
    */
    {
    }
#endif
}
ExpressionPtr UnaryOpExpression::preOptimize(AnalysisResultConstPtr ar) {
  Variant value;
  Variant result;

  if (m_exp && ar->getPhase() >= AnalysisResult::FirstPreOptimize) {
    if (m_op == T_UNSET) {
      if (m_exp->isScalar() ||
          (m_exp->is(KindOfExpressionList) &&
           static_pointer_cast<ExpressionList>(m_exp)->getCount() == 0)) {
        recomputeEffects();
        return CONSTANT("null");
      }
      return ExpressionPtr();
    }
  }

  if (m_op == T_ISSET && m_exp->is(KindOfExpressionList) &&
      static_pointer_cast<ExpressionList>(m_exp)->getListKind() ==
      ExpressionList::ListKindParam) {
    auto el = static_pointer_cast<ExpressionList>(m_exp);
    result = true;
    int i = 0, n = el->getCount();
    for (; i < n; i++) {
      ExpressionPtr e((*el)[i]);
      if (!e || !e->isScalar() || !e->getScalarValue(value)) break;
      if (value.isNull()) {
        result = false;
      }
    }
    if (i == n) {
      return replaceValue(makeScalarExpression(ar, result));
    }
  } else if (m_op != T_ARRAY &&
             m_op != T_VEC &&
             m_op != T_DICT &&
             m_op != T_KEYSET &&
             m_exp &&
             m_exp->isScalar() &&
             m_exp->getScalarValue(value) &&
             preCompute(value, result)) {
    return replaceValue(makeScalarExpression(ar, result));
  } else if (m_op == T_BOOL_CAST) {
    switch (m_exp->getKindOf()) {
      default: break;
      case KindOfBinaryOpExpression: {
        int op = static_pointer_cast<BinaryOpExpression>(m_exp)->getOp();
        switch (op) {
          case T_LOGICAL_OR:
          case T_BOOLEAN_OR:
          case T_LOGICAL_AND:
          case T_BOOLEAN_AND:
          case T_LOGICAL_XOR:
          case T_INSTANCEOF:
          case '<':
          case T_IS_SMALLER_OR_EQUAL:
          case '>':
          case T_IS_GREATER_OR_EQUAL:
          case T_SPACESHIP:
          case T_IS_IDENTICAL:
          case T_IS_NOT_IDENTICAL:
          case T_IS_EQUAL:
          case T_IS_NOT_EQUAL:
            return m_exp;
        }
        break;
      }
      case KindOfUnaryOpExpression: {
        int op = static_pointer_cast<UnaryOpExpression>(m_exp)->getOp();
        switch (op) {
          case T_BOOL_CAST:
          case '!':
          case T_ISSET:
          case T_EMPTY:
          case T_PRINT:
            return m_exp;
        }
        break;
      }
    }
  }
  return ExpressionPtr();
}
Beispiel #4
0
void
MainWindow::update()
{
  if(this->actionShowConvexHull->isChecked()){
    convex_hull_gi->show();
  }else {
    convex_hull_gi->hide();
  }

  if(this->actionShowMinRectangle->isChecked()){
    min_rectangle_gi->show();
  }else {
    min_rectangle_gi->hide();
  }


  if(this->actionShowMinParallelogram->isChecked()){
    min_parallelogram_gi->show();
  }else {
    min_parallelogram_gi->hide();
  }

  CGAL::Qt::Converter<K> convert;  

  if(this->actionShowPCenter->isChecked() && convex_hull.size()>=3){
    for(std::size_t i=0; i< P; i++){
      p_center[i]->setRect(convert(p_center_iso_rectangle[i]));
      p_center[i]->show();
    }
  }

  if (mc.is_degenerate() || (! this->actionShowMinCircle->isChecked())){
    cgi->hide();
  } else {
    K::Circle_2 c;
    if (mc.number_of_support_points() == 2) 
      c = K::Circle_2(mc.support_point(0), mc.support_point(1));
    else
      c = K::Circle_2(mc.support_point(0), mc.support_point(1), mc.support_point(2));
    

    cgi->setRect(convert(c.bbox()));
    cgi->show();
  }

  if (me.is_degenerate()  || (! this->actionShowMinEllipse->isChecked()) ){
    egi->hide();
  } else {
    if (me.number_of_support_points() == 2) {
    } else {
      Ellipse_2<K> e(me);
      double half_width = sqrt(e.va() * e.va());
      double half_height = sqrt(e.vb() * e.vb());
      double angle = std::atan2( e.va().y(), e.va().x() ) * 180.0/CGAL_PI;
      Vector_2 wh(half_width, half_height);

      Iso_rectangle_2 isor(e.center()+ wh, e.center()-wh);
      egi->setRect(convert(isor));
      // Rotate an item 45 degrees around (x, y).
      double x = e.center().x();
      double y = e.center().y();
      egi->setTransform(QTransform().translate(x, y).rotate(angle).translate(-x, -y));
      egi->show();
    } 
  }
}
Beispiel #5
0
Datei: gflops.c Projekt: yoyz/mpi
double addmul_sse()
{
  long long ii;
  double    res;
  double    mul=1.00001;

  Vec2d  a(0.1, 0.2);
  Vec2d  b(0.3, 0.4);
  Vec2d  c(0.5, 0.6);
  Vec2d  d(0.7, 0.8);

  Vec2d  e(2.1, 2.2);
  Vec2d  f(2.3, 2.4);
  Vec2d  g(2.5, 2.6);
  Vec2d  h(2.7, 2.8);

  Vec2d  i(3.1, 3.2);
  Vec2d  j(3.3, 3.4);
  Vec2d  k(3.5, 3.6);
  Vec2d  l(3.7, 3.8);

  Vec2d  m(4.1, 4.2);
  Vec2d  n(4.3, 4.4);
  Vec2d  o(4.5, 4.6);
  Vec2d  p(4.7, 4.8);

  
  for(ii=0; ii< max1*max2 ; ii++)
    {
      a=a*b;
      b=b+c;
      c=c*d;
      d=d+e;
   
      e=e*f;
      f=f+g;
      g=g*h;
      h=h+i;

      i=i*j;
      j=j+k;
      k=k*l;
      l=l+m;

      m=m*n;
      n=n+o;
      o=o*p;
      p=p+a;
    }

  res=
    a[0]+a[1]+
    b[0]+b[1]+
    c[0]+c[1]+
    d[0]+d[1]+

    e[0]+e[1]+
    f[0]+f[1]+
    g[0]+g[1]+
    h[0]+h[1]+

    i[0]+i[1]+
    j[0]+j[1]+
    k[0]+k[1]+
    l[0]+l[1]+

    m[0]+m[1]+
    n[0]+n[1]+
    o[0]+o[1]+
    p[0]+p[1]

  ;

  return res;

}
int main(int argc, char **argv) {
  const int d = 5;
  const int da[5] = { 0 };
  S4 e(4);
  S5 g(5);
  S6 p;
  int i;
  int &j = i;

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate // expected-error {{expected '(' after 'firstprivate'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate () // expected-error {{expected expression}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (argc)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (S1) // expected-error {{'S1' does not refer to a value}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate (argv[1]) // expected-error {{expected variable name}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(ba)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(ca) // expected-error {{no matching constructor for initialization of 'S3'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(da)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(S2::S2s)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(S2::S2sc)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd private(i), firstprivate(i) // expected-error {{private variable cannot be firstprivate}} expected-note 2 {{defined as private}}
  for (i = 0; i < argc; ++i) foo(); // expected-error {{loop iteration variable in the associated loop of 'omp teams distribute parallel for simd' directive may not be private, predetermined as linear}}

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(i)
  for (j = 0; j < argc; ++j) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(i) // expected-note {{defined as firstprivate}}
  for (i = 0; i < argc; ++i) foo(); // expected-error {{loop iteration variable in the associated loop of 'omp teams distribute parallel for simd' directive may not be firstprivate, predetermined as linear}}

#pragma omp target
#pragma omp teams distribute parallel for simd firstprivate(j)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target
#pragma omp teams distribute parallel for simd lastprivate(argc), firstprivate(argc) // OK
  for (i = 0; i < argc; ++i) foo();

  return 0;
}
Beispiel #7
0
//
//   Assign facets
//        assign common facets
//        assign additional facet
//
void AbstractStringValidator::assignFacet(MemoryManager* const manager)
{

    RefHashTableOf<KVStringPair>* facets = getFacets();

    if (!facets)
        return;

    XMLCh* key;
    RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);

    while (e.hasMoreElements())
    {
        KVStringPair pair = e.nextElement();
        key = pair.getKey();
        XMLCh* value = pair.getValue();

        if (XMLString::equals(key, SchemaSymbols::fgELT_LENGTH))
        {
            int val;
            try
            {
                val = XMLString::parseInt(value, manager);
            }
            catch (NumberFormatException&)
            {
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Len, value, manager);
            }

            if ( val < 0 )
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_Len, value, manager);

            setLength(val);
            setFacetsDefined(DatatypeValidator::FACET_LENGTH);
        }
        else if (XMLString::equals(key, SchemaSymbols::fgELT_MINLENGTH))
        {
            int val;
            try
            {
                val = XMLString::parseInt(value, manager);
            }
            catch (NumberFormatException&)
            {
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_minLen, value, manager);
            }

            if ( val < 0 )
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_minLen, value, manager);

            setMinLength(val);
            setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
        }
        else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXLENGTH))
        {
            int val;
            try
            {
                val = XMLString::parseInt(value, manager);
            }
            catch (NumberFormatException&)
            {
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_maxLen, value, manager);
            }

            if ( val < 0 )
                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_maxLen, value, manager);

            setMaxLength(val);
            setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
        }
        else if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
        {
            setPattern(value);
            if (getPattern())
                setFacetsDefined(DatatypeValidator::FACET_PATTERN);
            // do not construct regex until needed
        }
        else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
        {
            unsigned int val;
            bool         retStatus;
            try
            {
                retStatus = XMLString::textToBin(value, val, fMemoryManager);
            }
            catch (RuntimeException&)
            {
                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
            }

            if (!retStatus)
            {
                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
            }

            setFixed(val);
            //no setFacetsDefined here
        }
        //
        // else if (XMLString::equals(key, SchemaSymbols::fgELT_SPECIAL_TOKEN))
        // TODO
        //
        // Note: whitespace is taken care of by TraverseSchema.
        //
        else
        {
            assignAdditionalFacet(key, value, manager);
        }
    }//while
}//end of assigneFacet()
int main(int argc, char **argv) {
  const int d = 5;       // expected-note 2 {{'d' defined here}}
  const int da[5] = {0}; // expected-note {{'da' defined here}}
  int qa[5] = {0};
  S4 e(4);
  S5 g(5);
  int i;
  int &j = i;                  // expected-note 2 {{'j' defined here}}
  S3 &p = k;                   // expected-note 2 {{'p' defined here}}
  const int &r = da[i];        // expected-note {{'r' defined here}}
  int &q = qa[i];              // expected-note {{'q' defined here}}
  float fl;
#pragma omp target teams distribute parallel for simd reduction // expected-error {{expected '(' after 'reduction'}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp target teams distribute parallel for simd' are ignored}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name, array element or array section}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(~ : argc) // expected-error {{expected unqualified-id}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(&& : argc)
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{const-qualified list item cannot be reduction}} expected-error {{'operator+' is a private member of 'S2'}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : ba) // expected-error {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(* : ca) // expected-error {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(- : da) // expected-error {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(&& : S2::S2sc) // expected-error {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(& : e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{invalid operands to binary expression ('S4' and 'S4')}} expected-error {{calling a private constructor of class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 'S5')}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : h, k, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : o) // expected-error {{no viable overloaded '='}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  for (int j=0; j<100; j++) foo();
#pragma omp parallel private(k)
#pragma omp target teams distribute parallel for simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : r) // expected-error {{const-qualified list item cannot be reduction}}
  for (int j=0; j<100; j++) foo();
#pragma omp parallel shared(i)
#pragma omp parallel reduction(min : i)
#pragma omp target teams distribute parallel for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
  for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(+ : fl)
    for (int j=0; j<100; j++) foo();
  static int m;
#pragma omp target teams distribute parallel for simd reduction(+ : m) // OK
  for (int j=0; j<100; j++) foo();

  return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
}
Beispiel #9
0
      /// Compute the conversion (in seconds) at the given time for this object
      /// (TimeSystemCorrection). The caller must ensure that the input time has the
      /// appropriate TimeSystem, it will determine the sign of the correction; it is
      /// such that it should ALWAYS be ADDED to the input time.
      /// For example, suppose this object is a "GPUT" (GPS=>UTC) correction. Then
      ///    ct(GPS) + Correction(ct) will yield ct(UTC), and
      ///    ct(UTC) + Correction(ct) will yield ct(GPS).
      ///    [That is, Correction(ct) in the two cases differ in sign]
      /// Throw an Exception if the TimeSystem of the input does not match either of
      /// the systems in this object.
      /// @param CommonTime ct, the time at which to compute the correction; the
      ///        TimeSystem of ct will determine the sign of the correction.
      /// @return the correction (sec) to be added to ct to change its TimeSystem
      /// @throw if the input TimeSystem matches neither system in this object.
      double Correction(const CommonTime& ct) const
      {
         double corr(0.0), dt;
         TimeSystem fromTS(ct.getTimeSystem());
         GPSWeekSecond gpsws;
         CommonTime refTime;
         Exception e("Unable to compute correction - wrong TimeSystem");
         Exception eSBAS("TimeSystemCorr SBAS <=> UTC has not been implemented");

         switch(type) {
            case GPUT:
               if(fromTS != TimeSystem::GPS && fromTS != TimeSystem::UTC)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::GPS)             // GPS => UTC
                  corr = -A0-A1*dt;
               else                                      // UTC => GPS
                  corr = A0+A1*dt;

               break;

            case GAUT:
               if(fromTS != TimeSystem::GAL && fromTS != TimeSystem::UTC)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::GAL)             // GAL => UTC
                  corr = A0+A1*dt;
               else                                      // UTC => GAL
                  corr = -A0-A1*dt;

               break;

            case SBUT:
               GPSTK_THROW(eSBAS);
               break;

            case GLUT:
               if(fromTS != TimeSystem::GLO && fromTS != TimeSystem::UTC)
                  { GPSTK_THROW(e); }

               if(fromTS == TimeSystem::GLO)             // GLO => UTC
                  corr = A0;
               else                                      // UTC => GLO
                  corr = -A0;

               break;

            case GPGA:
               if(fromTS != TimeSystem::GPS && fromTS != TimeSystem::GAL)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::GPS)             // GPS => GAL
                  corr = A0+A1*dt;
               else                                      // GAL => GPS
                  corr = -A0-A1*dt;

               break;

            case GLGP:
               if(fromTS != TimeSystem::GLO && fromTS != TimeSystem::GPS)
                  { GPSTK_THROW(e); }

               if(fromTS == TimeSystem::GLO)             // GLO => GPS
                  corr = A0;
               else                                      // GPS => GLO
                  corr = -A0;

               break;

            case QZGP:
               if(fromTS != TimeSystem::QZS && fromTS != TimeSystem::GPS)
                  { GPSTK_THROW(e); }

               if(fromTS == TimeSystem::QZS)             // QZS => GPS
                  corr = 0.0;    // TD?
               else                                      // GPS => QZS
                  corr = 0.0;    // TD?

               break;

            case QZUT:
               if(fromTS != TimeSystem::QZS && fromTS != TimeSystem::UTC)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::QZS)             // QZS => UTC
                  corr = A0+A1*dt;
               else                                      // UTC => QZS
                  corr = -A0-A1*dt;

               break;

            case BDUT:
               if(fromTS != TimeSystem::BDT && fromTS != TimeSystem::UTC)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::BDT)             // BDT => UTC
                  corr = A0+A1*dt;
               else                                      // UTC => BDT
                  corr = -A0-A1*dt;

               break;

            case BDGP:
               if(fromTS != TimeSystem::BDT && fromTS != TimeSystem::GPS)
                  { GPSTK_THROW(e); }

               // dt = fromTime - refTime
               gpsws = GPSWeekSecond(refWeek,refSOW);
               refTime = gpsws.convertToCommonTime();
               refTime.setTimeSystem(fromTS);
               dt = ct - refTime;

               if(fromTS == TimeSystem::BDT)             // BDT => GPS
                  corr = A0;
               else                                      // GPS => BDT
                  corr = -A0;

               break;

            default:
               Exception e("TimeSystemCorrection is not defined.");
               GPSTK_THROW(e);
               break;
         }

         return corr;
      }
Beispiel #10
0
void Bayes::sample_muOmega() {
  double tau = 10.0;
  int d0 = p + 2;
  // matrix_t S0(p, p);
  ublas::matrix<double> S0(p, p);
  S0 = d0 * ublas::identity_matrix<double>(p, p)/4.0;
  
  std::vector<int> idx;
  ublas::indirect_array<> irow(p);
  // projection - want every row
  for (size_t i=0; i<irow.size(); ++i)
    irow(i) = i;
  
  // size_t rank;
  ublas::matrix<double> S(p, p);
  // matrix_t SS(p, p);
  ublas::matrix<double> SS(p, p);
  ublas::matrix<double> Omega_inv(p, p);

  // identity matrix for inverting cholesky factorization
  ublas::matrix<double> I(p, p);
  I.assign(ublas::identity_matrix<double> (p, p));
  ublas::symmetric_adaptor<ublas::matrix<double>, ublas::upper> SH(I);

  // triangular matrix for cholesky_decompose
  ublas::triangular_matrix<double, ublas::lower, ublas::row_major> L(p, p);

  int df;
  for (int j=0; j<k; ++j) {
    idx = find_all(z, j);
    int n_idx = idx.size();

    ublas::matrix<double> xx(p, n_idx);
    ublas::matrix<double> e(p, n_idx);
    // ublas::matrix<double> m(p, 1);
    ublas::vector<double> m(p);

    ublas::indirect_array<> icol(n_idx);
    for (size_t i=0; i<idx.size(); ++i)
      icol(i) = idx[i];
    if (n_idx > 0) {
      double a = tau/(1.0 + n_idx*tau);
      //! REFACTOR - should be able to do matrix_sum directly on projection rather than make a copy?
      xx.assign(project(x, irow, icol));
      m.assign(ublas::matrix_sum(xx, 1)/n_idx);
      // e.assign(xx - outer_prod(column(m, 0), ublas::scalar_vector<double>(n_idx, 1)));
      e.assign(xx - outer_prod(m, ublas::scalar_vector<double>(n_idx, 1)));
      S.assign(prod(e, trans(e)) + outer_prod(m, m) * n_idx * a/tau);
      // SS = trans(S) + S0;
      SS = S + S0;
      df = d0 + n_idx;

      // Omega(j).assign(wishart_rnd(df, SS));
      Omega(j).assign(wishart_InvA_rnd(df, SS));
      SH.assign(Omega(j));
      cholesky_decompose(SH, L);
      Omega_inv.assign(solve(SH, I, ublas::upper_tag()));
      mu(j).assign(a*n_idx*m + sqrt(a)*prod(Omega_inv, Rmath::rnorm(0, 1, p)));
    } else {
      // Omega(j).assign(wishart_rnd(d0, S0));
      Omega(j).assign(wishart_InvA_rnd(d0, S0));
      SH.assign(Omega(j));
      cholesky_decompose(SH, L);
      Omega_inv.assign(solve(SH, I, ublas::upper_tag()));
      mu(j).assign(sqrt(tau) * prod(Omega_inv, Rmath::rnorm(0, 1, p)));
    }
  }
}
Beispiel #11
0
void
NasmInsnRunner::ParseAndTestLine(const char* filename,
                                 const llvm::StringRef& line,
                                 int linenum)
{
    SCOPED_TRACE(llvm::format("%s:%d", filename, linenum));

    llvm::StringRef insn_in, golden_in;
    llvm::tie(insn_in, golden_in) = line.split(';');

    insn_in = strip(insn_in);
    golden_in = strip(golden_in);

    // Handle bits directive
    if (golden_in.empty() && insn_in.startswith("[bits "))
    {
        int bits = atoi(insn_in.substr(6, 2).str().c_str());
        if (bits == 64)
            m_arch->setMachine("amd64");
        else
            m_arch->setMachine("x86");
        m_arch->setVar("mode_bits", bits);
        return;
    }

    if (insn_in.empty() || golden_in.empty())
        return;     // skip lines that don't have both text and a comment

    //
    // parse the golden result
    //
    llvm::SmallVector<unsigned char, 64> golden;
    llvm::StringRef golden_errwarn;

    for (;;)
    {
        // strip whitespace
        golden_in = strip(golden_in);
        if (golden_in.empty() || !isxdigit(golden_in[0]))
            break;

        unsigned int byte_val = 0x100;
        llvm::StringRef byte_str;
        llvm::tie(byte_str, golden_in) = golden_in.split(' ');

        if (byte_str.size() == 2)   // assume hex
            byte_val = (fromhexdigit(byte_str[0]) << 4)
                | fromhexdigit(byte_str[1]);
        else if (byte_str.size() == 3)  // assume octal
            byte_val = (fromoctdigit(byte_str[0]) << 6)
                | (fromoctdigit(byte_str[1]) << 3)
                | fromoctdigit(byte_str[2]);

        ASSERT_LE(byte_val, 0xffU) << "invalid golden value";
        golden.push_back(byte_val);
    }

    // interpret string in [] as error/warning
    if (!golden_in.empty() && golden_in[0] == '[')
        llvm::tie(golden_errwarn, golden_in) = golden_in.substr(1).split(']');

    //
    // parse the instruction
    //
    ::testing::StrictMock<MockDiagnosticString> mock_consumer;
    llvm::IntrusiveRefCntPtr<DiagnosticIDs> diagids(new DiagnosticIDs);
    DiagnosticsEngine diags(diagids, &mock_consumer, false);
    FileSystemOptions opts;
    FileManager fmgr(opts);
    SourceManager smgr(diags, fmgr);
    diags.setSourceManager(&smgr);

    // instruction name is the first thing on the line
    llvm::StringRef insn_name;
    llvm::tie(insn_name, insn_in) = insn_in.split(' ');
    Arch::InsnPrefix insnprefix =
        m_arch->ParseCheckInsnPrefix(insn_name, SourceLocation(), diags);
    ASSERT_TRUE(insnprefix.isType(Arch::InsnPrefix::INSN));
    std::auto_ptr<Insn> insn = m_arch->CreateInsn(insnprefix.getInsn());
    ASSERT_TRUE(insn.get() != 0) << "unrecognized instruction '"
        << insn_name.str() << "'";

    // parse insn arguments
    unsigned int wsize = m_arch_module->getWordSize();

    // strip whitespace from arguments
    insn_in = strip(insn_in);

    while (!insn_in.empty())
    {
        llvm::StringRef arg_str;
        llvm::tie(arg_str, insn_in) = insn_in.split(',');

        // strip whitespace from arg
        arg_str = strip(arg_str);

        unsigned int size = 0;
        bool strict = false;
        for (;;)
        {
            int next;
            int nsize = 0;
            // operand overrides (size and strict)
            if (arg_str.startswith("byte ")) { nsize = 8; next = 5; }
            else if (arg_str.startswith("hword ")) { nsize = wsize/2; next = 6; }
            else if (arg_str.startswith("word ")) { nsize = wsize; next = 5; }
            else if (arg_str.startswith("dword ")) { nsize = wsize*2; next = 6; }
            else if (arg_str.startswith("qword ")) { nsize = wsize*4; next = 6; }
            else if (arg_str.startswith("tword ")) { nsize = 80; next = 6; }
            else if (arg_str.startswith("dqword ")) { nsize = wsize*8; next = 7; }
            else if (arg_str.startswith("oword ")) { nsize = wsize*8; next = 6; }
            else if (arg_str.startswith("yword ")) { nsize = 256; next = 6; }
            else if (arg_str.startswith("strict ")) { strict = true; next = 7; }
            else break;

            if (size == 0)
                size = nsize;
            arg_str = arg_str.substr(next);
        }

        if (arg_str[0] == '[')
        {
            // Very simple int/reg expression parser.  Does not handle parens or
            // order of operations; simply builds expr from left to right.
            // This means r8*4+r9 will have a different result than r9+r8*4!
            // Also only handles binary operators * and +.
            llvm::StringRef estr = arg_str.slice(1, arg_str.find(']')+1);
            std::auto_ptr<Expr> e(new Expr);

            char pendingop = '\0';
            std::size_t tokstart = 0;
            for (std::size_t pos = 0; pos < estr.size(); ++pos)
            {
                if (estr[pos] == '*' || estr[pos] == '+' || estr[pos] == ']')
                {
                    // figure out this token
                    llvm::StringRef tok = strip(estr.slice(tokstart, pos));
                    if (isdigit(estr[tokstart]))
                        e->Append(strtoint(tok));
                    else
                    {
                        Arch::RegTmod regtmod =
                            m_arch->ParseCheckRegTmod(tok,
                                                      SourceLocation(),
                                                      diags);
                        ASSERT_TRUE(regtmod.isType(Arch::RegTmod::REG))
                            << "cannot handle label '" << tok.str() << "'";
                        e->Append(*regtmod.getReg());
                    }

                    // append pending operator
                    if (pendingop == '*')
                        e->AppendOp(Op::MUL, 2);
                    else if (pendingop == '+')
                        e->AppendOp(Op::ADD, 2);

                    // store new operator
                    pendingop = estr[pos];
                    tokstart = pos+1;
                }
            }

            Operand operand(m_arch->CreateEffAddr(e));
            operand.setSize(size);
            operand.setStrict(strict);
            insn->AddOperand(operand);
            continue;
        }

        // TODO: split by space to allow target modifiers

        // Test for registers
        Arch::RegTmod regtmod =
            m_arch->ParseCheckRegTmod(arg_str, SourceLocation(), diags);
        if (const Register* reg = regtmod.getReg())
        {
            Operand operand(reg);
            operand.setSize(size);
            operand.setStrict(strict);
            insn->AddOperand(operand);
            continue;
        }
        else if (const SegmentRegister* segreg = regtmod.getSegReg())
        {
            Operand operand(segreg);
            operand.setSize(size);
            operand.setStrict(strict);
            insn->AddOperand(operand);
            continue;
        }
        else if (regtmod.getTargetMod())
        {
            FAIL() << "cannot handle target modifier";
        }
        else if (regtmod.getRegGroup())
        {
            FAIL() << "cannot handle register group";
        }

        // Can't handle labels
        ASSERT_TRUE(isdigit(arg_str[0]) || arg_str[0] == '-')
            << "cannot handle label '" << arg_str.str() << "'";

        // Convert to integer expression
        Operand intop(Expr::Ptr(new Expr(strtoint(arg_str))));
        intop.setSize(size);
        intop.setStrict(strict);
        insn->AddOperand(intop);
    }

    TestInsn(insn.get(), golden.size(), golden.data(), golden_errwarn);
}
Beispiel #12
0
bool SynPacket::answer(const char *_cmd, vector<string> &args)
{
    string cmd = _cmd;
    if (cmd == "SYN"){
        m_ver = atol(args[0].c_str());
        if (m_ver == m_client->getListVer())
            return false;
        ContactList::GroupIterator itg;
        Group *grp;
        while ((grp = ++itg) != NULL){
            MSNUserData *data;
            ClientDataIterator it(grp->clientData, m_client);
            while ((data = (MSNUserData*)(++it)) != NULL){
                data->sFlags = data->Flags;
                data->Flags  = 0;
            }
        }
        ContactList::ContactIterator itc;
        Contact *contact;
        while ((contact = ++itc) != NULL){
            MSNUserData *data;
            ClientDataIterator it(contact->clientData, m_client);
            while ((data = (MSNUserData*)(++it)) != NULL){
                data->sFlags = data->Flags;
                data->Flags = 0;
            }
        }
        return true;
    }
    if (cmd == "GTC")
        return true;
    if (cmd == "BLP")
        return true;
    if (cmd == "LSG"){
        if (args.size() < 3){
            log(L_WARN, "Bad LSG size");
            return true;
        }
        unsigned id = atol(args[0].c_str());
        if (id == 0)
            return true;
        Group *grp;
        string grp_name;
        grp_name = m_client->unquote(QString::fromUtf8(args[1].c_str())).utf8();
        MSNListRequest *lr = m_client->findRequest(id, LR_GROUPxREMOVED);
        if (lr)
            return true;
        MSNUserData *data = m_client->findGroup(id, NULL, grp);
        if (data){
            lr = m_client->findRequest(grp->id(), LR_GROUPxCHANGED);
            if (lr){
                data->sFlags |= MSN_CHECKED;
                return true;
            }
        }
        data = m_client->findGroup(id, grp_name.c_str(), grp);
        data->sFlags |= MSN_CHECKED;
        return true;
    }
    if (cmd == "LST"){
        if (args.size() < 3){
            log(L_WARN, "Bad size for LST");
            return true;
        }
        string mail;
        mail = m_client->unquote(QString::fromUtf8(args[0].c_str())).utf8();
        string name;
        name = m_client->unquote(QString::fromUtf8(args[1].c_str())).utf8();
        Contact *contact;
        MSNListRequest *lr = m_client->findRequest(mail.c_str(), LR_CONTACTxREMOVED);
        if (lr)
            return true;
        bool bNew = false;
        MSNUserData *data = m_client->findContact(mail.c_str(), contact);
        if (data == NULL){
            data = m_client->findContact(mail.c_str(), name.c_str(), contact);
            bNew = true;
        }else{
            set_str(&data->EMail, mail.c_str());
            set_str(&data->ScreenName, name.c_str());
            if (name != (const char*)(contact->getName().utf8())){
                contact->setName(QString::fromUtf8(name.c_str()));
                Event e(EventContactChanged, contact);
                e.process();
            }
        }
        data->sFlags |= MSN_CHECKED;
        lr = m_client->findRequest(mail.c_str(), LR_CONTACTxCHANGED);
        unsigned grp = NO_GROUP;
        if (args.size() > 3)
            grp = atol(args[3].c_str());
        data->Group = grp;
        data->Flags |= MSN_FORWARD;
        Group *group = NULL;
        if (grp == NO_GROUP){
            group = getContacts()->group(0);
        }else{
            m_client->findGroup(grp, NULL, group);
        }
        if ((lr == NULL) && group && (group->id() != contact->getGroup())){
            unsigned grp = group->id();
            if (grp == 0){
                void *d;
                ClientDataIterator it_d(contact->clientData);
                while ((d = ++it_d) != NULL){
                    if (d != data)
                        break;
                }
                if (d){
                    grp = contact->getGroup();
                    m_client->findRequest(data->EMail, LR_CONTACTxCHANGED, true);
                    MSNListRequest lr;
                    lr.Type = LR_CONTACTxCHANGED;
                    lr.Name = data->EMail;
                    m_client->m_requests.push_back(lr);
                    m_client->processRequests();
                }
            }
            contact->setGroup(grp);
            Event e(EventContactChanged, contact);
            e.process();
        }
        return true;
    }
    bDone = true;
    return false;
}
Beispiel #13
0
int POD<TruthModelType>::pod( mode_set_type& ModeSet, bool is_primal, const wn_type& elements_set, bool use_solutions )
{
    M_backend = backend_type::build( BACKEND_PETSC );

    Eigen::SelfAdjointEigenSolver< matrixN_type > eigen_solver;
    M_use_solutions = use_solutions;

    fillPodMatrix( elements_set );
    int size = M_pod_matrix.cols();

    //store the matrix
    if ( M_store_pod_matrix )
    {
        std::ofstream matrix_file;
        LOG(INFO)<<"saving Pod matrix in a file \n";
        matrix_file.open( "PodMatrix",std::ios::out );
        matrix_file<<M_pod_matrix.rows();
        matrix_file<<"\n";
        matrix_file<<M_pod_matrix.cols();
        matrix_file<<"\n";

        for ( int i=0; i<M_pod_matrix.rows(); i++ )
        {
            for ( int j=0; j<M_pod_matrix.cols(); j++ )
            {
                matrix_file<< std::setprecision( 16 ) <<M_pod_matrix( i,j )<<" ";
            }

            matrix_file<<"\n";
        }

        LOG(INFO)<<" matrix wrote in file named PodMatrix \n";
    }

    else if ( M_store_pod_matrix_format_octave )
    {
        std::ofstream matrix_file;
        LOG(INFO)<<"saving Pod matrix in a file \n";
        matrix_file.open( "PodMatrixOctave.mat",std::ios::out );
        matrix_file<<"# name: A\n";
        matrix_file<<"# type: matrix\n";
        matrix_file<<"# rows: "<<M_pod_matrix.rows()<<"\n";
        matrix_file<<"# columns: "<<M_pod_matrix.cols()<<"\n";

        for ( int i=0; i<M_pod_matrix.rows(); i++ )
        {
            for ( int j=0; j<M_pod_matrix.cols(); j++ )
            {
                matrix_file<< std::setprecision( 16 ) <<M_pod_matrix( i,j )<<" ";
            }

            matrix_file<<"\n";
        }

        LOG(INFO)<<" matrix wrote in file named PodMatrix \n";
        matrix_file.close();
    }


    eigen_solver.compute( M_pod_matrix ); // solve M_pod_matrix psi = lambda psi

    int number_of_eigenvalues =  eigen_solver.eigenvalues().size();
    LOG(INFO)<<"Number of eigenvalues  : "<<number_of_eigenvalues<<"\n";
    //we copy eigenvalues in a std::vector beacause it's easier to manipulate it
    std::vector<double> eigen_values( number_of_eigenvalues );

    int too_small_index = 0;

    for ( int i=0; i<number_of_eigenvalues; i++ )
    {
        if ( imag( eigen_solver.eigenvalues()[i] )>1e-12 )
        {
            throw std::logic_error( "[POD::pod] ERROR : complex eigenvalues were found" );
        }

        eigen_values[i]=real( eigen_solver.eigenvalues()[i] );
    }


    //tab will contains index of maximum eigenvalues
    std::vector<int> max_idx;
    std::vector<double> copy_eigen_values ( eigen_values );
    int number_of_good_eigenvectors=0;
    bool go = true;
    double min_eigenvalue = option(_name="pod.minimum-eigenvalue").template as<double>();
    //for(int maxmode=0; maxmode<M_Nm; maxmode++)
    auto max = std::max_element( copy_eigen_values.begin(), copy_eigen_values.end() );
    double idx = std::distance( copy_eigen_values.begin(), max );
    if( *max < min_eigenvalue )
        go=false;
    while( go )
    {
        number_of_good_eigenvectors++;
        max_idx.push_back( idx );
        copy_eigen_values[idx]=0;
        max = std::max_element( copy_eigen_values.begin(), copy_eigen_values.end() );
        idx = std::distance( copy_eigen_values.begin(), max );
        if( *max < min_eigenvalue )
            go = false;
        if( number_of_good_eigenvectors == M_Nm )
            go = false;
        if( number_of_good_eigenvectors == number_of_eigenvalues )
            go = false;
    }

    CHECK( number_of_good_eigenvectors > 0 )<<"The max eigenvalue "<<*max<<" is under the minimum eigenvalue set by the user "<<min_eigenvalue<<" and we have zero eigenvectors !\n";

    int position_of_largest_eigenvalue=max_idx[0];

    if( M_Nm == -1 )
    {
        //in this case the user doesn't know a priori
        //what value give to M_Nm
        //this case appears for when apply-POD-to-WN=true
        M_Nm = number_of_good_eigenvectors;
    }
    if ( M_Nm > number_of_good_eigenvectors && number_of_good_eigenvectors>0 && is_primal )
    {
        //in this case, the user set M_Nm but with respect to
        //the minimum eigenvalue set, we don't find enough eigenvectors
        M_Nm = number_of_good_eigenvectors;
    }

    for ( int i=0; i<M_Nm; i++ )
    {
        element_ptrtype mode ( new element_type( M_model->functionSpace() ) );
        mode->zero();

        int index=0;

        if( M_use_solutions )
        {
            M_bdf->setRestart( true );

            for ( M_bdf->restart(); !M_bdf->isFinished(); M_bdf->next() )
            {
                M_bdf->loadCurrent();
                double psi_k = real( eigen_solver.eigenvectors().col( position_of_largest_eigenvalue )[index] );
                M_bdf->unknown( 0 ).scale( psi_k );
                mode->add( 1 , M_bdf->unknown( 0 ) );
                index++;
            }
        }//if use solutions
        else
        {
            double eigenvalue = eigen_values[ position_of_largest_eigenvalue ];
            for(int j=0; j<size; j++)
            {
                double psi_k = real( eigen_solver.eigenvectors().col( position_of_largest_eigenvalue )[index] );
                mode->add( psi_k , elements_set[j] );
                index++;
            }
        }//if use elements set


        //check
        auto eigenvector = eigen_solver.eigenvectors().col( position_of_largest_eigenvalue );
        double eigenvalue = eigen_values[position_of_largest_eigenvalue];
        auto Aw = M_pod_matrix*eigenvector;
        auto lambdaw = eigenvalue*eigenvector;
        double Awnorm = Aw.norm();
        double lambdawnorm = lambdaw.norm();
        double eigenvectornorm = eigenvector.norm();
        double check_tol = option(_name="pod.check-tol").template as<double>();
        CHECK( math::abs(Awnorm - lambdawnorm) < check_tol )<<" A w : "<<Awnorm<<" and lambda w : "<<lambdawnorm<<" so math::abs(A w - lambda w) : "<<math::abs(Awnorm - lambdawnorm)<<" and pod.check-tol : "<<check_tol<<" -- eigenvalue : "<<eigenvalue<<"\n";

        if( (i+1) < max_idx.size() )
            position_of_largest_eigenvalue=max_idx[i+1];
        ModeSet.push_back( *mode );
    }// loop on number of modes


    //check orthogonality
    if( option(_name="pod.check-orthogonality").template as<bool>() )
    {
        position_of_largest_eigenvalue=max_idx[0];
        for(int i=1; i<M_Nm; i++)
        {
            auto modei = ModeSet[i-1];
            for(int j=i+1; j<M_Nm; j++)
            {
                auto modej = ModeSet[j-1];
                double prod = M_model->scalarProductForPod( modei , modej );
                CHECK( prod < 1e-10 )<<"scalar product between mode "<<i<<" and mode "<<j<<" is not null and is "<<prod<<"\n";
            }
            double eigenvalue = eigen_values[ position_of_largest_eigenvalue ];
            double prod = M_model->scalarProductForPod( modei , modei );
            {
                CHECK( (prod - eigenvalue) < 1e-12 )<<"scalar product between mode "<<i<<" and mode "<<i<<" is "<<prod<<" and associated eigenvalue : "<<eigenvalue<<" ( i = "<<i<<") \n";
            }
            if( i < max_idx.size() )
                position_of_largest_eigenvalue=max_idx[i];
        }
    }

    if ( M_store_pod_matrix_format_octave )
    {
        std::cout<<"M_store_pod_matrix_format_octave = "<<M_store_pod_matrix_format_octave<<std::endl;
        std::ofstream eigenvalue_file;
        eigenvalue_file.open( "eigen_values.mat",std::ios::out );
        eigenvalue_file<<"# name: E\n";
        eigenvalue_file<<"# type: matrix\n";
        eigenvalue_file<<"# rows: "<<number_of_eigenvalues<<"\n";
        eigenvalue_file<<"# columns: 1\n";

        for ( int i=0; i<number_of_eigenvalues; i++ )
        {
            eigenvalue_file<<std::setprecision( 16 )<<eigen_values[i]<<"\n";
        }

        eigenvalue_file.close();


        std::ofstream eigenvector_file( ( boost::format( "eigen_vectors" ) ).str().c_str() );

        for ( int j=0; j<M_pod_matrix.cols(); j++ )
        {
            for ( int i=0; i<number_of_eigenvalues; i++ )
            {
                eigenvector_file<<std::setprecision( 16 )<<eigen_solver.eigenvectors().col( i )[j] <<" ";
            }

            eigenvector_file<<"\n";
        }

        eigenvector_file.close();


        for ( int i=0; i<M_Nm; i++ )
        {
            std::ofstream mode_file( ( boost::format( "mode_%1%" ) %i ).str().c_str() );
            element_type e = ModeSet[i];

            for ( size_type j=0; j<e.size(); j++ ) mode_file<<std::setprecision( 16 )<<e( j )<<"\n";

            mode_file.close();
        }

    }

    return M_Nm;

}
void BufferedSerialDevice::update(ofEventArgs& args)
{
    if (!isOpen()) return;

    Poco::Buffer<uint8_t> buffer(UPDATE_BUFFER_SIZE);

    try
    {
        while (available())
        {
            std::size_t nBytes = pSerial->read(buffer.begin(),
                                               UPDATE_BUFFER_SIZE);

            for (std::size_t i = 0; i < nBytes; ++i)
            {
                if (buffer[i] == _marker)
                {
                    // Decode the buffer if needed.
                    //decodeBuffer();

                    // Send the buffer if there are any bytes.
                    if (buffer.size() > 0)
                    {
                        SerialBufferEventArgs args(_buffer);
                        ofNotifyEvent(events.onSerialBuffer, args, this);
                    }

                    _buffer.reserve(_maxBufferSize);
                    _buffer.clear();
                }
                else
                {
                    if (_buffer.size() + 1 >= _maxBufferSize)
                    {
                        // Send the overflow;
                        std::stringstream ss;
                        ss << "maxBufferSize exceeded: " << _maxBufferSize;

                        Poco::Exception exception(ss.str());

                        SerialBufferErrorEventArgs args(exception,
                                                        _buffer);

                        ofNotifyEvent(events.onSerialError, args, this);

                        _buffer.reserve(_maxBufferSize);
                        _buffer.clear();
                    }

                    _buffer.writeByte(buffer[i]);
                }
            }
        }
    }
    catch (const Poco::Exception& exc)
    {
        SerialBufferErrorEventArgs args(exc);
        ofNotifyEvent(events.onSerialError, args, this);
    }
    catch (const std::exception& exc)
    {
        Poco::Exception e(exc.what());
        SerialBufferErrorEventArgs args(e);
        ofNotifyEvent(events.onSerialError, args, this);
    }
    catch (...)
    {
        Poco::Exception exc("Unknown error.");
        SerialBufferErrorEventArgs args(exc);
        ofNotifyEvent(events.onSerialError, args, this);
    }
}
int main(int argc, char **argv) {
  const int d = 5;
  const int da[5] = {0};
  S4 e(4);
  S5 g(5);
  S3 m;
  S6 n(2);
  int i;
  int &j = i;
#pragma omp parallel
#pragma omp single firstprivate // expected-error {{expected '(' after 'firstprivate'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate() // expected-error {{expected expression}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc)
  foo();
#pragma omp parallel
#pragma omp single firstprivate(S1) // expected-error {{'S1' does not refer to a value}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argv[1]) // expected-error {{expected variable name}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(2 * 2) // expected-error {{expected variable name}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(ba) // OK
  foo();
#pragma omp parallel
#pragma omp single firstprivate(ca) // OK
  foo();
#pragma omp parallel
#pragma omp single firstprivate(da) // OK
  foo();
  int xa;
#pragma omp parallel
#pragma omp single firstprivate(xa) // OK
  foo();
#pragma omp parallel
#pragma omp single firstprivate(S2::S2s) // OK
  foo();
#pragma omp parallel
#pragma omp single firstprivate(S2::S2sc) // OK
  foo();
#pragma omp parallel
#pragma omp single safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp single'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(m) // OK
  foo();
#pragma omp parallel
#pragma omp single firstprivate(h, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be firstprivate}}
  foo();
#pragma omp parallel
#pragma omp single private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}}
  foo();
#pragma omp parallel shared(xa)
#pragma omp single firstprivate(xa) // OK: may be firstprivate
  foo();
#pragma omp parallel
#pragma omp single firstprivate(j)
  foo();
#pragma omp parallel
#pragma omp single firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(n) // OK
  foo();
#pragma omp parallel
  {
    int v = 0;
    int i;                         // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp single' directive into a parallel or another task region?}}
#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}}
    foo();
    v += i;
  }
#pragma omp parallel private(i)    // expected-note {{defined as private}}
#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}}
  foo();
#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}}
#pragma omp single firstprivate(i)    // expected-error {{firstprivate variable must be shared}}
  foo();
  static int t;
#pragma omp single firstprivate(t)    // OK
  foo();

  return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}
int main(int argc, char **argv) {
  const int d = 5;       // expected-note {{constant variable is predetermined as shared}}
  const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
  S4 e(4);
  S5 g(5);
  S3 m;
  S6 n(2);
  int i;
  int &j = i;
  float k;
#pragma omp target teams distribute parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate() // expected-error {{expected expression}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(argc)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(S1) // expected-error {{'S1' does not refer to a value}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(argv[1]) // expected-error {{expected variable name}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(2 * 2) // expected-error {{expected variable name}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(ba)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(da) // expected-error {{shared variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

  int xa;
#pragma omp target teams distribute parallel for lastprivate(xa) // OK
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(B::x) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(xa)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(j)
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
  for (i = 0; i < argc; ++i) foo();

#pragma omp target teams distribute parallel for lastprivate(n) firstprivate(n) // OK
  for (i = 0; i < argc; ++i) foo();

  static int si;
#pragma omp target teams distribute parallel for lastprivate(si) // OK
  for (i = 0; i < argc; ++i) si = i + 1;

#pragma omp target teams distribute parallel for lastprivate(k) map(k) // expected-error {{lastprivate variable cannot be in a map clause in '#pragma omp target teams distribute parallel for' directive}} expected-note {{defined as lastprivate}}
  for (i = 0; i < argc; ++i) foo();

  return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}
int foomain(int argc, char **argv) {
  I e(4);
  C g(5);
  int i;
  int &j = i;
#pragma omp parallel
#pragma omp single firstprivate // expected-error {{expected '(' after 'firstprivate'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate() // expected-error {{expected expression}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argc)
  foo();
#pragma omp parallel
#pragma omp single firstprivate(S1) // expected-error {{'S1' does not refer to a value}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(argv[1]) // expected-error {{expected variable name}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
  foo();
#pragma omp parallel
#pragma omp single firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}}
  foo();
#pragma omp parallel
#pragma omp single linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp single'}}
  foo();
#pragma omp parallel
  {
    int v = 0;
    int i;                         // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp single' directive into a parallel or another task region?}}
#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}}
    foo();
    v += i;
  }
#pragma omp parallel shared(i)
#pragma omp parallel private(i)
#pragma omp single firstprivate(j)
  foo();
#pragma omp parallel
#pragma omp single firstprivate(i)
  foo();
#pragma omp parallel
#pragma omp single firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}}
  foo();
#pragma omp parallel private(i)    // expected-note {{defined as private}}
#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}}
  foo();
#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}}
#pragma omp single firstprivate(i)    // expected-error {{firstprivate variable must be shared}}
  foo();
  return 0;
}
Beispiel #18
0
//
// Queues an EVT_TOOLBAR_UPDATED command event to notify any
// interest parties of an updated toolbar or dock layout
//
void ToolManager::Updated()
{
   // Queue an update event
   wxCommandEvent e( EVT_TOOLBAR_UPDATED );
   mParent->GetEventHandler()->AddPendingEvent( e );
}
Beispiel #19
0
int _tmain(int argc, _TCHAR* argv[]) {

	//q::IHttp* httpclient = q::create(3);

// 	RefPtr<DownloadController> controller = new DownloadController;
// 	if(0 != downloaders->download(
// 		"http://sq2.newhua.com/down/LeapFTP3.0.1.46_yfy.zip", 
// 		"C:\\a.zip", 
// 		controller
// 	)) 
// 	{
// 		printf("error create download task.");
// 	}

	//RefPtr<q::IHttpRequest> request;
	//httpclient->createHttpRequest(&request.ptr_);
	////"http://localhost/phpkind/?app=cdmusic&mod=service&inajax=true&action=top100", 
	//if(!request->open(
	//	"http://sq2.newhua.com/down/LeapFTP3.0.1.46_yfy.zip",
	//	q::GET,
	//	new ReadyStateChange,
	//	"D:\\test.wma"
	//	)) 
	//{
	//	printf("error create download task.");
	//}

	//request->send();

	//std::streambuf* old = std::cout.rdbuf();

//	while(true) {
//		Sleep(1000);
// 		system("cls");
// 		std::cout << "downloaded: " << controller->get_download() << " bytes";
// 		
// 		if(controller->IsCompleted()) {
// 			printf("Download Completed.\r\n");
// 			break;
// 		}
//	}

//	controller->Dump();
//	httpclient->release();
//	system("pause");
	//return 0;
// #ifdef USING_TestCode
// 	QUI::Color::doTest();
// #endif
//	std::cout << "value is A = " << (int)((unsigned char)(value >> 24)) << std::endl;
// 	unsigned long value = 0x01020304;
// 	std::cout << "value is R" << (int)((unsigned char)value) << std::endl;
// 	std::cout << "value is G" << (int)((unsigned char)(value >> 8)) << std::endl;
// 	std::cout << "value is B" << (int)((unsigned char)(value >> 16)) << std::endl;
// 	std::cout << "value is A" << (int)((unsigned char)(value >> 24)) << std::endl;
	
//	return 0;

// 	tstring sPath = _T("a/b/c/d/e.htm");
// 	ZZipFile::ZZipFileTree::PathType path;
// 	ZZipFile::ZZipFileTree::String2Path(sPath, path);
// 	tstring sPathOutput;
// 	ZZipFile::ZZipFileTree::Path2String(path,sPathOutput);
	bool bRet = true;
	// TODO:
	// do something
	std::cout << "ZZipApp is running" << std::endl;
	wchar_t WCharString[] = {0xff,0x22,0xad,0x33,0x00};
	tstring sString = _T("abcdefghijklmn");
	sString.append(1, _T('\0'));
	sString.append(1, _T('\0'));
	sString.append(1, _T('\0'));
	std::cout << wcslen(sString.c_str()) << std::endl;

	std::cout << sString.size() << std::endl;
	std::cout << sizeof(ZZipFileItem) << std::endl;
	ZZipFile zzip;
	// if(argc <= 1) { return 0; }
	tstring sZZipFileName = _T("D:/Developing/VCCode/trunk/QUI/Wayixia/res/skin.zzip");
	// if(zzip.Open(argv[1])) {
	if(zzip.Open(sZZipFileName)) {
		zzip.AddFolder(_T("/"), _T("D:/Developing/VCCode/trunk/QUI/Wayixia/skin"));
// 		zzip.AddFile(_T("/1.txt"), _T("C:\\1.txt"));
// 		zzip.AddFile(_T("/2.txt"), _T("C:\\2.txt"));
// 		zzip.AddFile(_T("/3.txt"), _T("C:\\3.txt"));
// 		zzip.AddFile(_T("/4.gif"), _T("C:\\4.gif"));
		zzip.Save();
		zzip.Close();
	}

	ZZipFile zzip2;
	if(zzip2.Open(sZZipFileName)) {

		// 枚举文件
		EnumItems e(zzip2, _T("/"), true);
// 		ZZipFile::ZZipFileTree::ValueTravEvent evt;
// 		evt += std::make_pair(&e, &EnumItems::EnumFile);
// 		zzip.EnumItem(_T("/"), evt, false);
// 		evt -= std::make_pair(&e, &EnumItems::EnumFile);

//		ZZipEnum<EnumItems>(zzip2, _T("/drawables"), false);
// 
// 		// 读取文件"/4.gif" 保存到 "C:\\tt.gif"
// 		RefPtr<ZZipFileObject> p = zzip.FindFile(_T("/4.gif"));
// 		if(NULL != p) {
// 			std::ofstream of(_T("C:\\tt.gif"), std::ios::out|std::ios::binary);
// 			if(of.good()) {
// 				char buffer[1024] = {0};
// 				int64 filesize = p->filesize();
// 				int64 startpos = 0;
// 				int64 fcount = filesize;
// 				while(fcount > 0) {
// 					int64 ReadBytes = zzip.ReadData(p, startpos, (void*)buffer, 1024);
// 					if(ReadBytes > 0) {
// 						fcount -= ReadBytes;
// 						startpos += ReadBytes;
// 						of.write(buffer, ReadBytes);
// 					} else {
// 						break;
// 					}
// 				}
// 				of.close();
// 			}
// 		}
		
		zzip2.Close();
	}
	return 0;
}
template<class I, class C> int foomain(I argc, C **argv) {
  I e(argc);
  I g(argc);
  int i; // expected-note {{declared here}} expected-note {{'i' defined here}}
  // expected-note@+2 {{declared here}}
  // expected-note@+1 {{reference to 'i' is not a constant expression}}
  int &j = i;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned // expected-error {{expected '(' after 'aligned'}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned () // expected-error {{expected expression}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned (argv[1]) // expected-error {{expected variable name}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(e, g)
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(h) // expected-error {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}
  for (I k = 0; k < argc; ++k) ++k;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(i) // expected-error {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}}
  for (I k = 0; k < argc; ++k) ++k;

  #pragma omp parallel
  {
    int *v = 0;
    I i;
    #pragma omp target
    #pragma omp teams
    #pragma omp distribute parallel for simd aligned(v:16)
      for (I k = 0; k < argc; ++k) { i = k; v += 2; }
  }
  float *f;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(f)
  for (I k = 0; k < argc; ++k) ++k;

  int v = 0;

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(f:j) // expected-note {{initializer of 'j' is not a constant expression}} expected-error {{expression is not an integral constant expression}}

  for (I k = 0; k < argc; ++k) { ++k; v += j; }

#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd aligned(f)
  for (I k = 0; k < argc; ++k) ++k;

  return 0;
}
Beispiel #21
0
void *ICQSearchResult::processEvent(Event *e)
{
    if ((e->type() > EventUser) && m_id && (m_id != SEARCH_FAIL)){
        ICQPlugin *plugin = static_cast<ICQPlugin*>(m_client->protocol()->plugin());
        if (e->type() == plugin->EventSearch){
            SearchResult *result = (SearchResult*)(e->param());
            if ((result->id == m_id) && (result->client == m_client)){
                new UserTblItem(tblUser, m_client, &result->data);
                m_nFound++;
                setStatus();
            }
        }
        if (e->type() == plugin->EventSearchDone){
            SearchResult *result = (SearchResult*)(e->param());
            if ((result->id == m_id) && (result->client == m_client))
                setRequestId(0);
        }
    }
    if (e->type() == EventCommandExec){
        CommandDef *cmd = (CommandDef*)(e->param());
        if (cmd->menu_id == static_cast<ICQPlugin*>(m_client->protocol()->plugin())->MenuSearchResult){
            Contact *contact;
            if (cmd->id == static_cast<ICQPlugin*>(m_client->protocol()->plugin())->CmdSendMessage){
                contact = createContact(CONTACT_TEMP);
                if (!contact) return NULL;
                Message msg(MessageGeneric);
                msg.setContact(contact->id());
                Event e(EventOpenMessage, &msg);
                e.process();
            }
            if (cmd->id == CmdInfo){
                contact = createContact(CONTACT_TEMP);
                if (!contact) return NULL;
                m_client->addFullInfoRequest(atol(tblUser->currentItem()->text(0).latin1()), true);
                Command cmd;
                cmd->id = CmdInfo;
                cmd->menu_id = MenuContact;
                cmd->param   = (void*)contact->id();
                Event e(EventCommandExec, cmd);
                e.process();
            }
            return e->param();
        }
        if (cmd->menu_id == static_cast<ICQPlugin*>(m_client->protocol()->plugin())->MenuGroups){
            Contact *contact = createContact(0);
            if (!contact) return NULL;
            contact->setGroup(cmd->id - 1);
            Event eContact(EventContactChanged, contact);
            eContact.process();
            return e->param();
        }
    }
    if (e->type() == EventCheckState){
        CommandDef *cmd = (CommandDef*)(e->param());
        if ((cmd->menu_id == static_cast<ICQPlugin*>(m_client->protocol()->plugin())->MenuGroups) &&
                (cmd->id == static_cast<ICQPlugin*>(m_client->protocol()->plugin())->CmdGroups)){
            unsigned n = 1;
            ContactList::GroupIterator it;
            while (++it)
                n++;
            CommandDef *cmds = new CommandDef[n];
            memset(cmds, 0, sizeof(CommandDef) * n);
            n = 0;
            it.reset();
            Group *grp;
            while ((grp = ++it) != NULL){
                cmds[n].id		 = grp->id() + 1;
                cmds[n].text	 = "_";
                QString name = grp->getName();
                if (grp->id() == 0)
                    name = i18n("Not in list");
                cmds[n].text_wrk = strdup(name.utf8());
                n++;
            }
            cmd->param = cmds;
            cmd->flags |= COMMAND_RECURSIVE;
            return e->param();
        }
    }
    return NULL;
}
bool mdtSerialPortPosix::checkConfig(mdtSerialPortConfig cfg)
{
  Q_ASSERT(pvFd >= 0);

  // Get current system config
  tcgetattr(pvFd, &pvTermios);

  // Check static coded flags
  if(!(pvTermios.c_cflag & (CLOCAL | CREAD))){
    mdtError e(MDT_UNDEFINED_ERROR, "CLOCAL and CREAD are not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(pvTermios.c_lflag & (ICANON | ECHO | ECHOE | ISIG)){
    mdtError e(MDT_UNDEFINED_ERROR, "raw data mode not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(pvTermios.c_oflag & OPOST){
    mdtError e(MDT_UNDEFINED_ERROR, "raw data mode not set (OPOST is on)", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  // Check parameters given by cfg
  if(baudRate() != cfg.baudRate()){
    mdtError e(MDT_UNDEFINED_ERROR, "baud rate is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(dataBits() != cfg.dataBitsCount()){
    mdtError e(MDT_UNDEFINED_ERROR, "data bits count is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(stopBits() != cfg.stopBitsCount()){
    qDebug() << "stopBits(): " << stopBits() << " , cfg: " << cfg.stopBitsCount();
    mdtError e(MDT_UNDEFINED_ERROR, "stop bits count is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(parity() != cfg.parity()){
    mdtError e(MDT_UNDEFINED_ERROR, "parity is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(flowCtlRtsCtsOn() != cfg.flowCtlRtsCtsEnabled()){
    mdtError e(MDT_UNDEFINED_ERROR, "Flow ctl RTS/CTS is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(flowCtlXonXoffOn() != cfg.flowCtlXonXoffEnabled()){
    mdtError e(MDT_UNDEFINED_ERROR, "Flow ctl Xon/Xoff is not set", mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    return false;
  }
  if(cfg.flowCtlXonXoffEnabled()){
    if(pvTermios.c_cc[VSTART] != cfg.xonChar()){
      mdtError e(MDT_UNDEFINED_ERROR, "Xon char is not set", mdtError::Error);
      MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
      e.commit();
      return false;
    }
    if(pvTermios.c_cc[VSTOP] != cfg.xoffChar()){
      mdtError e(MDT_UNDEFINED_ERROR, "Xoff char is not set", mdtError::Error);
      MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
      e.commit();
      return false;
    }
  }

  return true;
}
int main(int argc, const char* argv[])
{
   //
   // Set any additional text that should accumpany specific results:
   //
   extra_text["msvc-dist-beta-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   extra_text["msvc-dist-nbinom-R-quantile"] = "[footnote The R library appears to use a linear-search strategy, that can perform very badly in a small number of pathological cases, but may or may not be more efficient in \"typical\" cases]";
   extra_text["gcc-4_3_2-dist-beta-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   extra_text["gcc-4_3_2-dist-nbinom-R-quantile"] = "[footnote The R library appears to use a linear-search strategy, that can perform very badly in a small number of pathological cases, but may or may not be more efficient in \"typical\" cases]";
   extra_text["msvc-dist-hypergeometric-cdf"] = "[footnote This result is somewhat misleading: for small values of the parameters there is  virtually no difference between the two libraries, but for large values the Boost implementation is /much/ slower, albeit with much improved precision.]";
   extra_text["msvc-dist-nt-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   extra_text["msvc-dist-nchisq-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   extra_text["gcc-4_3_2-dist-hypergeometric-cdf"] = "[footnote This result is somewhat misleading: for small values of the parameters there is  virtually no difference between the two libraries, but for large values the Boost implementation is /much/ slower, albeit with much improved precision.]";
   extra_text["gcc-4_3_2-dist-nt-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   extra_text["gcc-4_3_2-dist-nchisq-R-quantile"] = "[footnote There are a small number of our test cases where the R library fails to converge on a result: these tend to dominate the performance result.]";
   
   boost::regex e("^Testing\\s+(\\S+)\\s+(\\S+)");
   std::string f;
   for(int i = 1; i < argc-1; ++i)
   {
      std::ifstream is(argv[i]);
      load_file(f, is);
      boost::sregex_iterator a(f.begin(), f.end(), e), b;
      while(a != b)
      {
         results[(*a).str(1)] = boost::lexical_cast<double>((*a).str(2));
         ++a;
      }
   }
   //
   // Load quickbook file:
   //
   std::ifstream is(argv[argc-1]);
   std::string bak_file = std::string(argv[argc-1]).append(".bak");
   std::ofstream os(bak_file.c_str());
   e.assign(
      "\\[perf\\s+([^\\s.]+)"
      "(?:"
         "\\[[^\\]\\[]*"
            "(?:\\[[^\\]\\[]*\\][^\\]\\[]*)?"
         "\\]"
         "|[^\\]]"
      ")*\\]");
   std::string newfile;
   while(is.good())
   {
      std::getline(is, f);
      os << f << std::endl;
      boost::sregex_iterator i(f.begin(), f.end(), e), j;
      double min = (std::numeric_limits<double>::max)();
      while(i != j)
      {
         std::cout << (*i).str() << std::endl << (*i).str(1) << std::endl;
         std::string item = (*i).str(1);
         if(results.find(item) != results.end())
         {
            double r = results[item];
            if(r < min)
               min = r;
         }
         ++i;
      }
      //
      // Now perform the substitutions:
      //
      std::string newstr;
      std::string tail;
      i = boost::sregex_iterator(f.begin(), f.end(), e);
      while(i != j)
      {
         std::string item = (*i).str(1);
         newstr.append(i->prefix());
         if(results.find(item) != results.end())
         {
            double v = results[item];
            double r = v / min;
            newstr += std::string((*i)[0].first, (*i)[1].second);
            newstr += "..[para ";
            if(r < 1.01)
               newstr += "*";
            newstr += (boost::format("%.2f") % r).str();
            if(r < 1.01)
               newstr += "*";
            if(extra_text.find(item) != extra_text.end())
            {
               newstr += extra_text[item];
            }
            newstr += "][para (";
            newstr += (boost::format("%.3e") % results[item]).str();
            newstr += "s)]]";
         }
         else
         {
            newstr.append(i->str());
            std::cerr << "Item " << item << " not found!!" << std::endl;
         }
         tail = i->suffix();
         ++i;
      }
      if(newstr.size())
         newfile.append(newstr).append(tail);
      else
         newfile.append(f);
      newfile.append("\n");
   }
   is.close();
   std::ofstream ns(argv[argc-1]);
   ns << newfile;
}
bool mdtSerialPortPosix::open(mdtSerialPortConfig &cfg)
{
  QString strNum;

  // Close previous opened device
  this->close();
  // Try to open port
  //  O_RDWR : Read/write access
  //  O_NOCTTY: not a terminal
  //  O_NDELAY: ignore DCD signal
  lockMutex();
  // In read only mode, we handle no lock
  if(cfg.readOnly()){
    pvFd = ::open(pvName.toStdString().c_str(), O_RDONLY | O_NOCTTY | O_NONBLOCK);
  }else{
    pvFd = pvPortLock->openLocked(pvName, O_RDWR | O_NOCTTY | O_NONBLOCK);
  }
  if(pvFd < 0){
    pvPortLock->unlock();
    mdtError e(MDT_UNDEFINED_ERROR, "Unable to open port: " + pvName, mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Get current config and save it to pvOriginalTermios
  if(tcgetattr(pvFd, &pvOriginalTermios) < 0){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    mdtError e(MDT_UNDEFINED_ERROR, "tcgetattr() failed, " + pvName + " is not a serial port, or is not available", mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Get current system config on "work copy"
  if(tcgetattr(pvFd, &pvTermios) < 0){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    mdtError e(MDT_UNDEFINED_ERROR, "tcgetattr() failed, " + pvName + " is not a serial port, or is not available", mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Set baud rate
  if(!setBaudRate(cfg.baudRate())){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    strNum.setNum(cfg.baudRate());
    mdtError e(MDT_UNDEFINED_ERROR, "unsupported baud rate '" + strNum + "' for port " + pvName, mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Set local mode and enable the receiver
  pvTermios.c_cflag |= (CLOCAL | CREAD);
  // Set data bits
  if(!setDataBits(cfg.dataBitsCount())){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    strNum.setNum(cfg.dataBitsCount());
    mdtError e(MDT_UNDEFINED_ERROR, "unsupported data bits count '" + strNum + "' for port " + pvName, mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Set stop bits
  if(!setStopBits(cfg.stopBitsCount())){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    strNum.setNum(cfg.stopBitsCount());
    mdtError e(MDT_UNDEFINED_ERROR, "unsupported stop bits count '" + strNum + "' for port " + pvName, mdtError::Error);
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Set parity
  setParity(cfg.parity());
  // Set flow control
  setFlowCtlRtsCts(cfg.flowCtlRtsCtsEnabled());
  setFlowCtlXonXoff(cfg.flowCtlXonXoffEnabled(), cfg.xonChar(), cfg.xoffChar());
  // Set raw data mode
  pvTermios.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
  pvTermios.c_oflag &= ~OPOST;
  // Apply the setup
  if(tcsetattr(pvFd, TCSANOW, &pvTermios) < 0){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    mdtError e(MDT_UNDEFINED_ERROR, "unable to apply configuration for port " + pvName, mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    unlockMutex();
    return false;
  }
  // Check if configuration could really be set
  if(!checkConfig(cfg)){
    ::close(pvFd);
    pvFd = -1;
    pvPortLock->unlock();
    unlockMutex();
    return false;
  }

  // Set the read/write timeouts
  setReadTimeout(cfg.readTimeout());
  setWriteTimeout(cfg.writeTimeout());

  return mdtAbstractPort::open(cfg);
}
Beispiel #25
0
Datei: gflops.c Projekt: yoyz/mpi
double addmul_avx()
{
  long long ii;
  double  res;
  double  mul=1.00001;

  Vec4d  a(0.1, 0.2, 0.3, 0.4);
  Vec4d  b(0.5, 0.6, 0.7, 0.8);
  Vec4d  c(0.9, 1.0, 1.1, 1.2);
  Vec4d  d(1.3, 1.4, 1.5, 1.6);

  Vec4d  e(2.1, 2.2, 2.3, 2.4);
  Vec4d  f(2.5, 2.6, 2.7, 2.8);
  Vec4d  g(2.9, 3.0, 3.1, 3.2);
  Vec4d  h(3.3, 3.4, 3.5, 3.6);

  Vec4d  i(4.1, 4.2, 4.3, 4.4);
  Vec4d  j(4.5, 4.6, 4.7, 4.8);
  Vec4d  k(4.9, 5.0, 5.1, 5.2);
  Vec4d  l(5.3, 5.4, 5.5, 5.6);

  Vec4d  m(6.1, 6.2, 6.3, 6.4);
  Vec4d  n(6.5, 6.6, 6.7, 6.8);
  Vec4d  o(6.9, 7.0, 7.1, 7.2);
  Vec4d  p(7.3, 7.4, 7.5, 7.6);

  
  for(ii=0; ii< max1*max2 ; ii++)
    {
      a=a*c;
      b=b+d;
      c=c*e;
      d=d+f;
   
      e=e*g;
      f=f+h;
      g=g*i;
      h=h+j;

      i=i*k;
      j=j+l;
      k=k*m;
      l=l+n;

      m=m*o;
      n=n+p;
      o=o*a;
      p=p+b;
    }

  res=
    a[0]+a[1]+a[2]+a[3] + 
    b[0]+b[1]+b[2]+b[3] + 
    c[0]+c[1]+c[2]+c[3] +
    d[0]+d[1]+d[2]+d[3] +

    e[0]+e[1]+e[2]+e[3] + 
    f[0]+f[1]+f[2]+f[3] + 
    g[0]+g[1]+g[2]+g[3] +
    h[0]+h[1]+h[2]+h[3] +

    i[0]+i[1]+i[2]+i[3] + 
    j[0]+j[1]+j[2]+j[3] + 
    k[0]+k[1]+k[2]+k[3] +
    l[0]+l[1]+l[2]+l[3] +

    m[0]+m[1]+m[2]+m[3] + 
    n[0]+n[1]+n[2]+n[3] + 
    o[0]+o[1]+o[2]+o[3] +
    p[0]+p[1]+p[2]+p[3] 

  ;

  return res;

}
bool mdtSerialPortPosix::setAttributes(const QString &portName)
{
  struct serial_struct serinfo;

  // Close previous opened port
  this->close();
  // Clear previous attributes
  pvAvailableBaudRates.clear();
  // Try to open port
  pvFd = ::open(portName.toStdString().c_str(), O_RDONLY | O_NOCTTY | O_NDELAY);
  if(pvFd < 0){
    mdtError e(MDT_UNDEFINED_ERROR, "can not open port '" + portName + "'", mdtError::Error);
    e.setSystemError(errno, strerror(errno));
    MDT_ERROR_SET_SRC(e, "mdtSerialPortPosix");
    e.commit();
    pvName = "";
    return false;
  }
  // Set port name
  pvName = portName;
  // Set the UART type
  if(ioctl(pvFd, TIOCGSERIAL, &serinfo) < 0){
    pvUartType = UT_UNKNOW;
    ::close(pvFd);
    return false;
  }
  // Map the type
  switch(serinfo.type){
    case PORT_8250:
      pvUartType = UT_8250;
    case PORT_16450:
      pvUartType = UT_16450;
      break;
    case PORT_16550:
      pvUartType = UT_16550;
      break;
    case PORT_16550A:
      pvUartType = UT_16550A;
      break;
    case PORT_CIRRUS:
      pvUartType = UT_CIRRUS;
      break;
    case PORT_16650:
      pvUartType = UT_16650;
      break;
    case PORT_16650V2:
      pvUartType = UT_16650V2;
      break;
    case PORT_16750:
      pvUartType = UT_16750;
      break;
    case PORT_STARTECH:
      pvUartType = UT_STARTECH;
      break;
    case PORT_16C950:
      pvUartType = UT_16C950;
      break;
    case PORT_16654:
      pvUartType = UT_16654;
      break;
    case PORT_16850:
      pvUartType = UT_16850;
      break;
    case PORT_RSA:
      pvUartType = UT_RSA;
      break;
    default:
      pvUartType = UT_UNKNOW;
      ::close(pvFd);
      return false;
  }
  // Get available baud rates list
  pvAvailableBaudRates << 50;
  pvAvailableBaudRates << 75;
  pvAvailableBaudRates << 110;
  pvAvailableBaudRates << 134; // Note: is 134.5
  pvAvailableBaudRates << 150;
  pvAvailableBaudRates << 200;
  pvAvailableBaudRates << 300;
  pvAvailableBaudRates << 600;
  pvAvailableBaudRates << 1200;
  pvAvailableBaudRates << 1800;
  pvAvailableBaudRates << 2400;
  pvAvailableBaudRates << 4800;
  pvAvailableBaudRates << 9600;
  pvAvailableBaudRates << 19200;
  pvAvailableBaudRates << 38400;
#ifdef  B57600
  pvAvailableBaudRates << 57600;
#endif
#ifdef B76800
  pvAvailableBaudRates << 76800;
#endif
#ifdef  B115200
  pvAvailableBaudRates << 115200;
#endif
#ifdef  B230400
  pvAvailableBaudRates << 230400;
#endif
#ifdef  B460800
  pvAvailableBaudRates << 460800;
#endif
#ifdef  B500000
  pvAvailableBaudRates << 500000;
#endif
#ifdef  B576000
  pvAvailableBaudRates << 576000;
#endif
#ifdef  B921600
  pvAvailableBaudRates << 921600;
#endif
#ifdef  B1000000
  pvAvailableBaudRates << 1000000;
#endif
#ifdef  B1152000
  pvAvailableBaudRates << 1152000;
#endif
#ifdef  B1500000
  pvAvailableBaudRates << 1500000;
#endif
#ifdef  B2000000
  pvAvailableBaudRates << 2000000;
#endif
#ifdef  B2500000
  pvAvailableBaudRates << 2500000;
#endif
#ifdef  B3000000
  pvAvailableBaudRates << 3000000;
#endif
#ifdef  B3500000
  pvAvailableBaudRates << 3500000;
#endif
#ifdef  B4000000
  pvAvailableBaudRates << 4000000;
#endif

  // End of attributes, close port
  ::close(pvFd);
  return true;
}
int main(int argc, char **argv) {
  const int d = 5;
  const int da[5] = { 0 };
  S4 e(4);
  S5 g(5);
  int i;
  int &j = i;
  #pragma omp target
  #pragma omp teams distribute parallel for shared // expected-error {{expected '(' after 'shared'}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared () // expected-error {{expected expression}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (argc)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (S1) // expected-error {{'S1' does not refer to a value}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (a, b, c, d, f) // expected-error {{incomplete type 'S1' where a complete type is required}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared (argv[1]) // expected-error {{expected variable name}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(ba)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(ca)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(da)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(e, g)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(h, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be shared}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for private(i), shared(i) // expected-error {{private variable cannot be shared}} expected-note {{defined as private}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for firstprivate(i), shared(i) // expected-error {{firstprivate variable cannot be shared}} expected-note {{defined as firstprivate}}
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for private(i)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(i)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for shared(j)
  for (int j=0; j<100; j++) foo();
  #pragma omp target
  #pragma omp teams distribute parallel for firstprivate(i)
  for (int j=0; j<100; j++) foo();

  return 0;
}
Beispiel #28
0
void do_test(void)
{
  int r, fd;
  int s[2];
  char buf[1], testroot[PATH_MAX+1], renamebuf[PATH_MAX+1];

  subtest = 1;
  if (socketpair(PF_UNIX, SOCK_STREAM, 0, s) == -1) e(1);
  if (system("mkdir -p " TEST_PATH) == -1) e(2);
  if (realpath(".", testroot) == NULL) e(3);

  r = fork();
  if (r == -1) e(4);
  else if (r == 0) { /* Child */
  	/* Change child's cwd to TEST_PATH */
  	if (chdir(TEST_PATH) == -1) e(5);

	/* Signal parent we're ready for the test */
	buf[0] = 'a';
	if (write(s[0], buf, sizeof(buf)) != sizeof(buf)) e(6);

	/* Wait for parent to remove my cwd */
	if (read(s[0], buf, sizeof(buf)) != sizeof(buf)) e(7);

	/* Try to create a file */
	if ((fd = open("testfile", O_RDWR | O_CREAT)) != -1) {
		e(8);
		/* Uh oh. We created a file?! Try to remove it. */
		(void) close(fd);
		if (unlink("testfile") != 0) {
			/* This is not good. We created a file, but we can
			 * never access it; we have a spurious inode.
			 */
			e(9);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}
	if (errno != ENOENT) e(10);

	/* Try to create a dir */
	errno = 0;
	if (mkdir("testdir", 0777) == 0) {
		e(11);
		/* Uh oh. This shouldn't have been possible. Try to undo. */
		if (rmdir("testdir") != 0) {
			/* Not good. */
			e(12);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}
	if (errno != ENOENT) e(13);

	/* Try to create a special file */
	errno = 0;
	if (mknod("testnode", 0777 | S_IFIFO, 0) == 0) {
		e(14);
		/* Impossible. Try to make it unhappen. */
		if (unlink("testnode") != 0) {
			/* Not good. */
			e(15);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}
	if (errno != ENOENT) e(16);

	/* Try to rename a file */
	errno = 0;
	/* First create a file in the test dir */
	snprintf(renamebuf, PATH_MAX, "%s/oldname", testroot);
	if ((fd = open(renamebuf, O_RDWR | O_CREAT)) == -1) e(17);
	if (close(fd) != 0) e(18);

	/* Now try to rename that file to an entry in the current, non-existing
	 * working directory.
	 */
	if (rename(renamebuf, "testrename") == 0) {
		e(19);
		/* This shouldn't have been possible. Revert the name change.
		 */
		if (rename("testrename", renamebuf) != 0) {
			/* Failed */
			e(20);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}

	/* Try to create a hard link to that file */
	errno = 0;
	if (link(renamebuf, "testhlink") == 0) {
		e(21);
		/* Try to undo the hard link to prevent fs corruption. */
		if (unlink("testhlink") != 0) {
			/* Failed. */
			e(22);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}
	if (errno != ENOENT) e(23);

	/* Try to create a symlink */
	errno = 0;
	if (symlink(testroot, "testslink") == 0) {
		e(24);
		/* Try to remove the symlink to prevent fs corruption. */
		if (unlink("testslink") != 0) {
			/* Failed. */
			e(25);
			printf(INTEGR_MSG);
			exit(errct);
		}
	}
	if (errno != ENOENT) e(26);

	exit(errct);
  } else { /* Parent */
  	int status;

  	/* Wait for the child to enter the TEST_PATH dir */
  	if (read(s[1], buf, sizeof(buf)) != sizeof(buf)) e(27);

  	/* Delete TEST_PATH */
  	if (rmdir(TEST_PATH) != 0) e(28);

  	/* Tell child we removed its cwd */
  	buf[0] = 'b';
  	if (write(s[1], buf, sizeof(buf)) != sizeof(buf)) e(29);

  	wait(&status);
  	errct += WEXITSTATUS(status);	/* Count errors */
  }
}
Beispiel #29
0
void NewClass::rec_type(int i,int j,int type,QString _tname) {
    tname=_tname;
if(type==1){
ui->pushButton->hide();
ui->pushButton_2->hide();
ui->pushButton_4->hide();
ui->pushButton_5->hide();
ui->pushButton_6->hide();
ui->pushButton_7->hide();
ui->pushButton_8->hide();
}
QSqlQuery query,q2,q3,q4,q5;
QString subname,teacher,classroom,ttype;
int week,time,id;
time=i;
week=j;
sendtype=type;
switch(i+1){
case 1:ui->label_3->setText("Monday NO."+QString::number(j+1,10));break;
    case 2:ui->label_3->setText("Tuesday NO."+QString::number(j+1,10));break;
    case 3:ui->label_3->setText("Wednesday NO."+QString::number(j+1,10));break;
    case 4:ui->label_3->setText("Thursday NO."+QString::number(j+1,10));break;
    case 5:ui->label_3->setText("Friday NO."+QString::number(j+1,10));break;
    case 6:ui->label_3->setText("Saturday NO."+QString::number(j+1,10));break;
    case 7:ui->label_3->setText("Sunday NO."+QString::number(j+1,10));break;

}
    query.exec("select name,teacher,id,classroom,type from subject where tname='"+tname+"' and time="+i+" and week="+j);

query.first();

    if(query.next())
    {


        qDebug() << query.value(0).toString() << query.value(1).toString()<<query.value(2).toString()<<query.value(3).toString();
        subname=query.value(0).toString();
        teacher=query.value(1).toString();


        id=query.value(2).toInt();
        classroom=query.value(3).toString();
        ttype=query.value(4).toString();
        ui->comboBox_2->clear();
        ui->comboBox_2->addItem(ttype);
        ui->comboBox_2->show();
        ui->lineEdit_3->setText(subname);
        ui->lineEdit->setText(teacher);
        ui->lineEdit_2->setText(classroom);

        q2.exec("select tutor_id from assist where class_id="+id);

        q2.first();
        do{
            q3.exec("select name,tel from tutor where id="+q2.value(0).toInt());

            if(q3.first()){
                Tutor tr(q3.value(0).toString(),q3.value(1).toString());
                tr.setId(q2.value(0).toInt());

                tutor->append(tr);
                ui->comboBox->addItem(tr.getName());
                ui->comboBox->show();
                q4.exec("select mail from mail where tutor_id="+q2.value(0).toInt());
                q4.first();
                do {

                    Email e(q4.value(0).toString());
                   e.setId(q2.value(0).toInt());
                    mail->append( e);

                }while(q4.next());


            }


        }while(q2.next());
        q5.exec("select title,type,time,text,mail from problem where class_id="+id);
        q5.first();
        do{
            Problem p(id,q5.value(0).toString(),q5.value(1).toInt(),q5.value(2).toString(),
                      q5.value(3).toString(),q5.value(4).toString());
            ui->comboBox_6->addItem(q5.value(0).toString());
            problem->append(p);
        }while(q5.next());



    }


}
Beispiel #30
0
//! compute the error between two visual features from a subset
//! a the possible features
vpColVector
vpFeatureEllipse::error(const vpBasicFeature &s_star,
			const unsigned int select)
{
  vpColVector e(0) ;

  try{
    if (vpFeatureEllipse::selectX() & select )
    {
      vpColVector ex(1) ;
      ex[0] = s[0] - s_star[0] ;

      e = vpMatrix::stackMatrices(e,ex) ;
    }

    if (vpFeatureEllipse::selectY() & select )
    {
      vpColVector ey(1) ;
      ey[0] = s[1] - s_star[1] ;
      e =  vpMatrix::stackMatrices(e,ey) ;
    }

     if (vpFeatureEllipse::selectMu20() & select )
    {
      vpColVector ex(1) ;
      ex[0] = s[2] - s_star[2] ;

      e = vpMatrix::stackMatrices(e,ex) ;
    }

    if (vpFeatureEllipse::selectMu11() & select )
    {
      vpColVector ey(1) ;
      ey[0] = s[3] - s_star[3] ;
      e =  vpMatrix::stackMatrices(e,ey) ;
    }

    if (vpFeatureEllipse::selectMu02() & select )
    {
      vpColVector ey(1) ;
      ey[0] = s[4] - s_star[4] ;
      e =  vpMatrix::stackMatrices(e,ey) ;
    }

  }
  catch(vpMatrixException me)
  {
    vpERROR_TRACE("caught a Matrix related error") ;
    std::cout <<std::endl << me << std::endl ;
    throw(me) ;
  }
  catch(vpException me)
  {
    vpERROR_TRACE("caught another error") ;
    std::cout <<std::endl << me << std::endl ;
    throw(me) ;
  }


  return e ;

}