Ejemplo n.º 1
0
bool Equation::trivialSolution( ) const
{
  Word image;
  Word::const_iterator w_it = theEquation.begin( );
  for( ; w_it!=theEquation.end( ) ; ++w_it )
    if( isGenerator(*w_it) )
      image.push_back( *w_it );
  
  return image.length()==0;
}
Ejemplo n.º 2
0
Func* Func::clone() const {
  Func* f = new (allocFuncMem(
        m_name,
        m_numParams,
        isClosureBody() || isGeneratorFromClosure()
  )) Func(*this);
  f->initPrologues(m_numParams, isGenerator());
  f->m_funcId = InvalidFuncId;
  return f;
}
Ejemplo n.º 3
0
fast_Ring<TNum,kdefs>::fast_Ring(   unsigned short _char, 
                        unsigned short _epsPrec, short _generator) :  characteristic(_char),
                                            epsilon(_epsPrec), 
                                            generator( Convert(_generator) )
{
    assert( TNum::wellDefined(characteristic) );
    assert( epsilon <= 1 );
    assert( isGenerator(generator));
    init();
    assert( wellDefined() );
}
Ejemplo n.º 4
0
std::string func_flag_list(const FuncInfo& finfo) {
  auto const func = finfo.func;
  std::vector<std::string> flags;

  if (func->isGenerator()) flags.push_back("isGenerator");
  if (func->isAsync()) flags.push_back("isAsync");
  if (func->isClosureBody()) flags.push_back("isClosureBody");
  if (func->isPairGenerator()) flags.push_back("isPairGenerator");

  std::string strflags = folly::join(" ", flags);
  if (!strflags.empty()) return " " + strflags + " ";
  return " ";
}
Ejemplo n.º 5
0
std::string func_flag_list(const FuncInfo& finfo) {
  auto const func = finfo.func;
  std::vector<std::string> flags;

  if (auto name = func->getGeneratorBodyName()) {
    flags.push_back(
        folly::format("hasGeneratorBody(\"{}\")", name->toCppString()).str()
    );
  }
  if (func->isGenerator()) flags.push_back("isGenerator");
  if (func->isAsync()) flags.push_back("isAsync");
  if (func->isGeneratorFromClosure()) flags.push_back("isGeneratorFromClosure");
  if (func->isClosureBody()) flags.push_back("isClosureBody");
  if (func->isPairGenerator()) flags.push_back("isPairGenerator");

  std::string strflags = folly::join(" ", flags);
  if (!strflags.empty()) return " " + strflags + " ";
  return " ";
}
Ejemplo n.º 6
0
void dhGenPubKey(dhpvk_t *pvk, dhpbk_t *pbk) {
    // Integer used for random numbers
    if (!seed_initialized)
        rnInit();

    do {
        mpz_urandomb(pbk->p, seed, DH_KEY_SIZE);        
    } while (!mpz_probab_prime_p(pbk->p, NB_TURN));
    mpz_set(pvk->p, pbk->p);

    mpz_set_ui(pbk->g, 2);
    // Search alpha so that alpha is a generator
    while(!isGenerator(pbk->p, pbk->g))
        mpz_add_ui(pbk->g, pbk->g, 1);

    mpz_set(pvk->g, pbk->g);

    mpz_urandomm(pvk->a, seed, pvk->p);

    mpz_powm(pbk->pow, pbk->g, pvk->a, pbk->p);
}
Ejemplo n.º 7
0
void egKeyGen(egpvk_t *pvk, egpbk_t *pbk) {
    // Useful for random generation
    if (!seed_initialized)
		rnInit();

    // Temporary variables
    mpz_t tmp;
    mpz_init(tmp);
    
    // p definition
    do {
        mpz_urandomb(pvk->p, seed, EG_KEY_SIZE);        
    } while (!mpz_probab_prime_p(pvk->p, NB_TURN));

    mpz_set(pbk->p, pvk->p);

    mpz_set_ui(pbk->alpha, 2);
    // Search alpha so that alpha is a generator
    while(!isGenerator(pbk->p, pbk->alpha))
        mpz_add_ui(pbk->alpha, pbk->alpha, 1);

    // Compute private key
    mpz_urandomb(pvk->a, seed, EG_KEY_SIZE);

    // Compute last part of public key
    mpz_powm(pbk->beta, pbk->alpha, pvk->a, pvk->p);

    // Compute k
    mpz_set_ui(tmp, NB_CHAR);
    pvk->k = 0;
    while (mpz_cmp(tmp, pbk->p) < 0) {
        mpz_mul_ui(tmp, tmp, NB_CHAR);
        pvk->k ++;
    }

    pbk->k = pvk->k;

    mpz_clear(tmp);
}
Ejemplo n.º 8
0
void tearDownFrame(ActRec*& fp, Stack& stack, PC& pc, Offset& faultOffset) {
  auto const func = fp->m_func;
  auto const curOp = *reinterpret_cast<const Op*>(pc);
  auto const unwindingGeneratorFrame = func->isGenerator();
  auto const unwindingReturningFrame = curOp == OpRetC || curOp == OpRetV;
  auto const prevFp = fp->arGetSfp();
  auto const soff = fp->m_soff;

  FTRACE(1, "tearDownFrame: {} ({})\n  fp {} prevFp {}\n",
         func->fullName()->data(),
         func->unit()->filepath()->data(),
         implicit_cast<void*>(fp),
         implicit_cast<void*>(prevFp));

  // When throwing from a constructor, we normally want to avoid running the
  // destructor on an object that hasn't been fully constructed yet. But if
  // we're unwinding through the constructor's RetC, the constructor has
  // logically finished and we're unwinding for some internal reason (timeout
  // or user profiler, most likely). More importantly, fp->m_this may have
  // already been destructed and/or overwritten due to sharing space with
  // fp->m_r.
  if (!unwindingReturningFrame && fp->isFromFPushCtor() && fp->hasThis()) {
    fp->getThis()->setNoDestruct();
  }

  // A generator's locals don't live on this stack.
  if (LIKELY(!unwindingGeneratorFrame)) {
    /*
     * If we're unwinding through a frame that's returning, it's only
     * possible that its locals have already been decref'd.
     *
     * Here's why:
     *
     *   - If a destructor for any of these things throws a php
     *     exception, it's swallowed at the dtor boundary and we keep
     *     running php.
     *
     *   - If the destructor for any of these things throws a fatal,
     *     it's swallowed, and we set surprise flags to throw a fatal
     *     from now on.
     *
     *   - If the second case happened and we have to run another
     *     destructor, its enter hook will throw, but it will be
     *     swallowed again.
     *
     *   - Finally, the exit hook for the returning function can
     *     throw, but this happens last so everything is destructed.
     *
     */
    if (!unwindingReturningFrame) {
      try {
        // Note that we must convert locals and the $this to
        // uninit/zero during unwind.  This is because a backtrace
        // from another destructing object during this unwind may try
        // to read them.
        frame_free_locals_unwind(fp, func->numLocals());
      } catch (...) {}
    }
    stack.ndiscard(func->numSlotsInFrame());
    stack.discardAR();
  } else {
    // The generator's locals will be cleaned up when the Continuation
    // object is destroyed. But we are leaving the generator function
    // now, so signal that to anyone who cares.
    try {
      EventHook::FunctionExit(fp);
    } catch (...) {} // As above, don't let new exceptions out of unwind.
  }

  /*
   * At the final ActRec in this nesting level.  We don't need to set
   * pc and fp since we're about to re-throw the exception.  And we
   * don't want to dereference prefFp since we just popped it.
   */
  if (prevFp == fp) return;

  assert(stack.isValidAddress(reinterpret_cast<uintptr_t>(prevFp)) ||
         prevFp->m_func->isGenerator());
  auto const prevOff = soff + prevFp->m_func->base();
  pc = prevFp->m_func->unit()->at(prevOff);
  fp = prevFp;
  faultOffset = prevOff;
}
Ejemplo n.º 9
0
void tearDownFrame(ActRec*& fp, Stack& stack, PC& pc, Offset& faultOffset) {
  auto const func = fp->m_func;
  auto const curOp = *reinterpret_cast<const Op*>(pc);
  auto const unwindingGeneratorFrame = func->isGenerator();
  auto const unwindingReturningFrame = curOp == OpRetC || curOp == OpRetV;
  auto const prevFp = fp->arGetSfp();

  FTRACE(1, "tearDownFrame: {} ({})\n  fp {} prevFp {}\n",
         func->fullName()->data(),
         func->unit()->filepath()->data(),
         implicit_cast<void*>(fp),
         implicit_cast<void*>(prevFp));

  if (fp->isFromFPushCtor() && fp->hasThis()) {
    fp->getThis()->setNoDestruct();
  }

  // A generator's locals don't live on this stack.
  if (LIKELY(!unwindingGeneratorFrame)) {
    /*
     * If we're unwinding through a frame that's returning, it's only
     * possible that its locals have already been decref'd.
     *
     * Here's why:
     *
     *   - If a destructor for any of these things throws a php
     *     exception, it's swallowed at the dtor boundary and we keep
     *     running php.
     *
     *   - If the destructor for any of these things throws a fatal,
     *     it's swallowed, and we set surprise flags to throw a fatal
     *     from now on.
     *
     *   - If the second case happened and we have to run another
     *     destructor, its enter hook will throw, but it will be
     *     swallowed again.
     *
     *   - Finally, the exit hook for the returning function can
     *     throw, but this happens last so everything is destructed.
     *
     */
    if (!unwindingReturningFrame) {
      try {
        // Note that we must convert locals and the $this to
        // uninit/zero during unwind.  This is because a backtrace
        // from another destructing object during this unwind may try
        // to read them.
        frame_free_locals_unwind(fp, func->numLocals());
      } catch (...) {}
    }
    stack.ndiscard(func->numSlotsInFrame());
    stack.discardAR();
  }

  assert(stack.isValidAddress(reinterpret_cast<uintptr_t>(prevFp)) ||
         prevFp->m_func->isGenerator());
  auto const prevOff = fp->m_soff + prevFp->m_func->base();
  pc = prevFp->m_func->unit()->at(prevOff);
  fp = prevFp;
  faultOffset = prevOff;
}