CSSM_RETURN CSSMAPI
CSSM_CSP_CreateDeriveKeyContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
CSSM_KEY_TYPE DeriveKeyType,
uint32 DeriveKeyLengthInBits,
const CSSM_ACCESS_CREDENTIALS *AccessCred,
const CSSM_KEY *BaseKey,
uint32 IterationCount,
const CSSM_DATA *Salt,
const CSSM_CRYPTO_DATA *Seed,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(DeriveKeyType, CSSMERR_CSP_INVALID_ATTR_KEY_TYPE);
maker.setup(DeriveKeyLengthInBits, CSSMERR_CSP_INVALID_ATTR_KEY_LENGTH);
maker.setup(AccessCred);
maker.setup(BaseKey);
maker.setup(IterationCount);
maker.setup(Salt);
maker.setup(Seed);
maker.make();
maker.put(CSSM_ATTRIBUTE_KEY_TYPE, DeriveKeyType);
maker.put(CSSM_ATTRIBUTE_KEY_LENGTH, DeriveKeyLengthInBits);
maker.put(CSSM_ATTRIBUTE_ACCESS_CREDENTIALS, AccessCred);
maker.put(CSSM_ATTRIBUTE_KEY, BaseKey);
maker.put(CSSM_ATTRIBUTE_ITERATION_COUNT, IterationCount);
maker.put(CSSM_ATTRIBUTE_SALT, Salt);
maker.put(CSSM_ATTRIBUTE_SEED, Seed);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_DERIVEKEY, AlgorithmID);
END_API(CSSM)
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateKeyGenContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
uint32 KeySizeInBits,
const CSSM_CRYPTO_DATA *Seed,
const CSSM_DATA *Salt,
const CSSM_DATE *StartDate,
const CSSM_DATE *EndDate,
const CSSM_DATA *Params,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(KeySizeInBits, CSSMERR_CSP_INVALID_ATTR_KEY_LENGTH);
maker.setup(Seed);
maker.setup(Salt);
maker.setup(StartDate);
maker.setup(EndDate);
maker.setup(Params);
maker.make();
maker.put(CSSM_ATTRIBUTE_KEY_LENGTH, KeySizeInBits);
maker.put(CSSM_ATTRIBUTE_SEED, Seed);
maker.put(CSSM_ATTRIBUTE_SALT, Salt);
maker.put(CSSM_ATTRIBUTE_START_DATE, StartDate);
maker.put(CSSM_ATTRIBUTE_END_DATE, EndDate);
maker.put(CSSM_ATTRIBUTE_ALG_PARAMS, Params);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_KEYGEN, AlgorithmID);
END_API(CSSM)
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateDigestContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.make();
Required(NewContextHandle) = maker(CSSM_ALGCLASS_DIGEST, AlgorithmID);
END_API(CSSM)
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreatePassThroughContext (CSSM_CSP_HANDLE CSPHandle,
const CSSM_KEY *Key,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(Key, CSSMERR_CSP_MISSING_ATTR_KEY);
maker.make();
maker.put(CSSM_ATTRIBUTE_KEY, Key);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_NONE, CSSM_ALGID_NONE);
END_API(CSSM)
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateMacContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
const CSSM_KEY *Key,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(Key, CSSMERR_CSP_MISSING_ATTR_KEY);
maker.make();
maker.put(CSSM_ATTRIBUTE_KEY, Key);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_MAC, AlgorithmID);
END_API(CSSM)
}
void WikiAreaPages::createAreaPages_createRegionPages( String wikiDir , MindArea *area ) {
MapStringToClass<MindRegion>& regions = area -> getRegions();
for( int k = 0; k < regions.count(); k++ ) {
WikiRegionPage maker( wm , wikiDir , regions.getClassByIndex( k ) );
maker.execute();
}
}
//装备打造
void equip_make(SceneUser* user,DWORD thisID,bool drop,int flag)
{
EquipMaker maker(NULL);
zObject* o = goi->getObjectByThisid(thisID);
if(o)
maker.assign(user,o,o->base,1);
}
/** Read from a file */
static int NcFile__init(PyClass<NcFile> *self, PyObject *args, PyObject *kwds)
{
try {
// Get arguments
char *fname_py = NULL;
char *filemode_py = NULL;
if (!PyArg_ParseTuple(args, "ss", &fname_py, &filemode_py)) {
// Throw an exception...
PyErr_SetString(PyExc_ValueError,
"Bad arguments to NcFile_save().");
return 0;
}
auto mode = ((strcmp(filemode_py, "w") == 0) ?
NcFile::Replace : NcFile::ReadOnly);
// Instantiate C++ NcFile
std::unique_ptr<NcFile> maker(new NcFile(fname_py, mode));
// Move it to Python NcFile object.
self->init(std::move(maker));
return 0;
} catch(...) {
PyErr_SetString(PyExc_ValueError, "Error in NcFile__init()");
return 0;
}
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateRandomGenContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
const CSSM_CRYPTO_DATA *Seed,
CSSM_SIZE Length,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(Seed);
maker.setup(Length, CSSMERR_CSP_INVALID_ATTR_OUTPUT_SIZE);
maker.make();
maker.put(CSSM_ATTRIBUTE_SEED, Seed);
maker.put(CSSM_ATTRIBUTE_OUTPUT_SIZE, Length);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_RANDOMGEN, AlgorithmID);
END_API(CSSM)
}
//
// Context management functions
//
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateSignatureContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
const CSSM_ACCESS_CREDENTIALS *AccessCred,
const CSSM_KEY *Key,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(AccessCred);
maker.setup(Key, CSSMERR_CSP_MISSING_ATTR_KEY);
maker.make();
maker.put(CSSM_ATTRIBUTE_ACCESS_CREDENTIALS, AccessCred);
maker.put(CSSM_ATTRIBUTE_KEY, Key);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_SIGNATURE, AlgorithmID);
END_API(CSSM)
}
void assign_set(DWORD thisid)
{
zObject* o = goi->getObjectByThisid(thisid);
if(o)
{
EquipMaker maker(NULL);
maker.assign_set(o);
}
}
JSBool SkJSDisplayable::Draw(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
SkJSDisplayable *p = (SkJSDisplayable*) JS_GetPrivate(cx, obj);
SkASSERT(p->fDisplayable->isDrawable());
SkDrawable* drawable = (SkDrawable*) p->fDisplayable;
SkAnimateMaker maker(NULL, gCanvas, gPaint);
drawable->draw(maker);
return JS_TRUE;
}
CWGSDataLoader::TRegisterLoaderInfo CWGSDataLoader::RegisterInObjectManager(
CObjectManager& om,
CObjectManager::EIsDefault is_default,
CObjectManager::TPriority priority)
{
SLoaderParams params;
TMaker maker(params);
CDataLoader::RegisterInObjectManager(om, maker, is_default, priority);
return maker.GetRegisterInfo();
}
sk_sp<SkImage> SkImage::makeTextureImage(GrContext *context) const {
if (!context) {
return nullptr;
}
if (GrTexture* peek = as_IB(this)->peekTexture()) {
return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(this)) : nullptr;
}
if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) {
GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint);
return create_image_from_maker(&maker, this->alphaType(), this->uniqueID());
}
if (const SkBitmap* bmp = as_IB(this)->onPeekBitmap()) {
GrBitmapTextureMaker maker(context, *bmp);
return create_image_from_maker(&maker, this->alphaType(), this->uniqueID());
}
return nullptr;
}
CAsnCache_DataLoader::TRegisterLoaderInfo CAsnCache_DataLoader::RegisterInObjectManager(
CObjectManager& om,
const string& db_path,
CObjectManager::EIsDefault is_default,
CObjectManager::TPriority priority)
{
TDbMaker maker(db_path);
CDataLoader::RegisterInObjectManager(om, maker, is_default, priority);
return maker.GetRegisterInfo();
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateAsymmetricContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
const CSSM_ACCESS_CREDENTIALS *AccessCred,
const CSSM_KEY *Key,
CSSM_PADDING Padding,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.setup(AccessCred, CSSMERR_CSP_MISSING_ATTR_ACCESS_CREDENTIALS);
maker.setup(Key, CSSMERR_CSP_MISSING_ATTR_KEY);
maker.setup(Padding);
maker.make();
maker.put(CSSM_ATTRIBUTE_ACCESS_CREDENTIALS, AccessCred);
maker.put(CSSM_ATTRIBUTE_KEY, Key);
maker.put(CSSM_ATTRIBUTE_PADDING, Padding);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_ASYMMETRIC, AlgorithmID);
END_API(CSSM)
}
sk_sp<SkImage> SkImage::makeTextureImage(GrContext *context) const {
if (!context) {
return nullptr;
}
if (GrTexture* peek = as_IB(this)->peekTexture()) {
return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(this)) : nullptr;
}
// No way to check whether a image is premul or not?
SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) {
GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint);
return create_image_from_maker(&maker, at, this->uniqueID());
}
SkBitmap bmp;
if (!this->asLegacyBitmap(&bmp, kRO_LegacyBitmapMode)) {
return nullptr;
}
GrBitmapTextureMaker maker(context, bmp);
return create_image_from_maker(&maker, at, this->uniqueID());
}
CSRADataLoader::TRegisterLoaderInfo CSRADataLoader::RegisterInObjectManager(
CObjectManager& om,
const string& rep_path,
const string& vol_path,
CObjectManager::EIsDefault is_default,
CObjectManager::TPriority priority)
{
SLoaderParams params;
params.m_RepPath = rep_path;
params.m_VolPath = vol_path;
TMaker maker(params);
CDataLoader::RegisterInObjectManager(om, maker, is_default, priority);
return maker.GetRegisterInfo();
}
bool Include::MakeMakefiles(bool Silent)
{
Maker maker(Silent, false, false, false);
for (auto goal : *this)
{
maker.AddGoal(goal);
}
for (auto file : ignoredFiles)
{
maker.SetIgnoreFailed(file);
}
maker.CreateDependencyTree();
return maker.RunCommands();
}
/**
* \brief 根据物品id调整物品在包裹中的数量,如果大于该物品最大数量则创建一个新物品
* \param user: 要改变包裹的用户
* \param id: 物品的objectid
* \param number: 增加的数量
* \param orig_ob: 数量被改变的物品,如果没有物品数量被改变,该参数被忽略
* \param new_obs: 新创建的物品的列表,如果没有物品被创建,该参数被忽略
* \param upgrade: 物品等级
* \author lqy
* \return 失败返回-1, 没有物品被创建返回0, 包裹满返回1, 成功添加所有创建的物品返回2
*/
int UserObjectM::addObjectNum(SceneUser* user, DWORD id, DWORD number, zObject* & orig_ob, Obj_vec& new_obs, BYTE upgrade)
{
//check if exist this object id
zObjectB* o = objectbm.get(id);
if (!o) {
return -1;
}
DWORD capacity = o->maxnum;
//check if we have a instance of this object which havn't reached max number
zObject* ob = getObjectByID(id, upgrade);
if (ob) {
number += ob->data.dwNum;
if (capacity >= number) { //have enough space to put this
ob->data.dwNum = number;
orig_ob = ob;
return 0;
}else { //space isn't enough, set max number first, then create new object
ob->data.dwNum = capacity;
number -= capacity;
orig_ob = ob;
}
}
while ((int)number > 0) {
zObject *tmp = zObject::create(o, (number>=capacity)?capacity:number, upgrade);
if (tmp) {
EquipMaker maker(NULL);
maker.assign(NULL, tmp, tmp->base);
if (user->packs.addObject(tmp, true, AUTO_PACK)) {
//如果是双倍经验道具和荣誉道具需要绑定
if(tmp->base->kind == ItemType_DoubleExp || tmp->base->kind == ItemType_Honor || tmp->base->kind == ItemType_ClearProperty)
{
tmp->data.bind=1;
}
zObject::logger(tmp->createid,tmp->data.qwThisID,tmp->data.strName,tmp->data.dwNum,tmp->data.dwNum,1,0,NULL,user->id,user->name,"新增",tmp->base,tmp->data.kind,tmp->data.upgrade);
new_obs.push_back(tmp);
}else {
//maybe package is full, stop process, but still return true
zObject::destroy(tmp);
return 1;
}
}
number -= capacity;
}
return 2;
}
void MazeWindow::createMaze() {
auto selected = algorithmSelector->currentText();
auto factory = MakerFactory::byName(selected);
maker = factory->maker();
int w,h;
w = h = dimensionSetter->value();
stepCount = 0;
maker->setGrid(Grid(w,h));
mazeWidget->setMaker(maker);
mazeWidget->setColorizer(factory->colorizer());
mazeWidget->repaint();
}
void makeRawTree(const Char_t* rawfilename,
const Char_t* outdir) {
TSnRawTreeMaker maker(rawfilename, outdir);
Printf("Making file [%s].",maker.GetTreeFilename().Data());
maker.ProcFile();
Printf("Wrote: %lld events, %lld power readings, %lld heartbeats.",
maker.GetNevtsWritten(),
maker.GetNpwrsWritten(),
maker.GetNhrtsWritten());
}
/**
* @brief RelationFactory::make
* @param relType
* @param tail
* @param head
* @param addToScene
* @return
*/
SharedRelation RelationFactory::make(RelationType relType, const common::ID &tail,
const common::ID &head, CreationOptions options) const
{
if (auto pr = G_ASSERT(project())) {
if (G_ASSERT(pr->database() && project()->globalDatabase())) {
if (auto maker = G_ASSERT(relationMaker[relType])) {
if (auto relation = maker(tail, head, {pr->database(), pr->globalDatabase()})) {
addRelation(relation, pr->database(), scene(), options);
return relation;
}
}
}
}
return nullptr;
}
/**
* Loads the given plugin from the specified library, including its
* construction and destruction functions.
*
* @param filepath full file path to the dynamic library containing the plugin
* @param classname the full name of the class comprising the conversion plugin
* @throws std::runtime_error
*/
void Plugin::load(const std::string& filepath, const std::string& classname)
{
const char *dlsym_error = dlerror(); // Reset error indicator
// Attempt to open the library
dll_ = std::shared_ptr<void>(dlopen(filepath.c_str(), RTLD_LAZY), dlclose);
dlsym_error = dlerror();
if (!dll_ || dlsym_error) {
throw std::runtime_error("Failed to open library " + filepath +
" (" + std::string(dlsym_error) + ")");
}
// Construct the name of the factory function (make_PluginName)
std::string maker("make_" + classname);
// then try to open it
typedef SequenceConverter* (*maker_type)();
maker_type create_converter = (maker_type) dlsym(dll_.get(), maker.c_str());
dlsym_error = dlerror();
if (dlsym_error) {
throw std::runtime_error("Failed to load plugin function " + maker +
" ( " + std::string(dlsym_error) + ")");
}
// Construct the name of the plugin destruction function (destroy_PluginName)
std::string destroyer = "destroy_" + classname;
// then try to open it
typedef void (*destroyer_type)(SequenceConverter *);
destroyer_type destroy_converter = (destroyer_type) dlsym(dll_.get(), destroyer.c_str());
dlsym_error = dlerror();
if (dlsym_error) {
throw std::runtime_error("Failed to load plugin function " + destroyer +
" (" + std::string(dlsym_error) + ")");
}
// Make `new` SequenceConverter class from DLL
try {
converter_ = std::shared_ptr<SequenceConverter>(create_converter(), destroy_converter);
} catch (const std::exception& e) {
throw std::runtime_error("Failed to create converter (" + std::string(e.what()) + ")");
}
}
/**
* @brief RelationFactory::make
* @param src
* @param addToScene
* @return
*/
SharedRelation RelationFactory::make(const QJsonObject &src, ErrorList &errors,
CreationOptions options) const
{
if (src.contains(relationship::Relation::typeMarker())) {
auto relType = RelationType(src[relationship::Relation::typeMarker()].toInt());
if (auto maker = G_ASSERT(relationMaker[relType])) {
db::WeakTypeSearchers ts {G_ASSERT(project())->database(), G_ASSERT(project())->globalDatabase()};
if (auto relation = maker(common::ID::nullID(), common::ID::nullID(), ts)) {
relation->fromJson(src, errors);
if (errors.isEmpty()) {
addRelation(relation, G_ASSERT(project())->database(), scene(), options);
return relation;
} else {
qWarning() << "Relation was loaded with errors.";
}
}
}
}
return nullptr;
}
//
// InternalRequirements
//
void InternalRequirements::operator () (const Requirements *given, const Requirements *defaulted, const Requirement::Context &context)
{
// first add the default internal requirements
if (defaulted) {
this->add(defaulted);
::free((void *)defaulted); // was malloc(3)ed by DiskRep
}
// now override them with any requirements explicitly given by the signer
if (given)
this->add(given);
// now add the Designated Requirement, if we can make it and it's not been provided
if (!this->contains(kSecDesignatedRequirementType)) {
DRMaker maker(context);
if (Requirement *dr = maker.make()) {
this->add(kSecDesignatedRequirementType, dr); // takes ownership of dr
}
}
// return the result
mReqs = this->make();
}
PMonsterAI MonsterAIFactory::getMonsterAI(Creature* c) {
return PMonsterAI(maker(c));
}
int MakeMain::Run(int argc, char **argv, char **env)
{
char *p = getenv("MAKEFLAGS");
if (p)
{
Variable *v = new Variable("MAKEFLAGS", p, Variable::f_recursive, Variable::o_environ);
*VariableContainer::Instance() += v;
p = getenv("MAKEOVERRIDES");
if (p)
{
Variable *v = new Variable("MAKEOVERRIDES", p, Variable::f_recursive, Variable::o_environ);
*VariableContainer::Instance() += v;
}
Eval r(v->GetValue(), false);
std::string cmdLine = r.Evaluate();
Dispatch(cmdLine.c_str());
}
if (!switchParser.Parse(&argc, argv) || help.GetValue() || help2.GetValue())
{
Utils::banner(argv[0]);
Utils::usage(argv[0], usageText);
}
if (dir.GetValue().size())
{
cwd = OS::GetWorkingDir();
if (!OS::SetWorkingDir(dir.GetValue()))
{
std::cout << "Cannot set working dir to: " << dir.GetValue() << std::endl;
return 2;
}
}
if (printDir.GetValue())
{
std::cout << OS::GetWorkingDir() << std::endl;
}
if (cancelKeep.GetValue())
{
cancelKeep.SetValue(false);
keepGoing.SetValue(false);
}
bool done = false;
Eval::Init();
Eval::SetWarnings(warnUndef.GetValue());
while (!done && !Eval::GetErrCount())
{
VariableContainer::Instance()->Clear();
RuleContainer::Instance()->Clear();
Include::Instance()->Clear();
Maker::ClearFirstGoal();
LoadEnvironment(env);
LoadCmdDefines();
SetVariable("MAKE", argv[0], Variable::o_environ, false);
Variable *v = VariableContainer::Instance()->Lookup("SHELL");
if (!v)
{
v = VariableContainer::Instance()->Lookup("COMSPEC");
if (!v)
v = VariableContainer::Instance()->Lookup("ComSpec");
if (v)
{
std::string val = v->GetValue();
SetVariable("SHELL", val, Variable::o_environ, true);
}
}
std::string goals;
for (int i=1; i < argc; i++)
{
if (goals.size())
goals += " ";
goals += argv[i];
}
SetVariable("MAKECMDGOALS", goals, Variable::o_command_line, false);
SetMakeFlags();
if (restarts)
{
std::strstream str;
std::string temp;
str << restarts;
str >> temp;
SetVariable("MAKE_RESTARTS", temp, Variable::o_command_line, false);
}
v = VariableContainer::Instance()->Lookup("MAKE_LEVEL");
if (!v)
{
SetVariable("MAKE_LEVEL", "0", Variable::o_environ, true);
}
else
{
std::strstream str;
std::string temp;
str << v->GetValue();
int n;
str >> n;
n++;
str << n;
str >> temp;
v->SetValue(temp);
}
SetVariable(".FEATURES","second-expansion order-only target-specific", Variable::o_environ, false);
SetVariable(".DEFAULT_GOAL","", Variable::o_environ, false);
SetVariable(".INCLUDE_DIRS",includes.GetValue(), Variable::o_command_line, false);
SetVariable("VPATH",includes.GetValue(), Variable::o_environ, false);
SetInternalVars();
v = VariableContainer::Instance()->Lookup("MAKEFILES");
if (v)
{
v->SetExport(true);
Include::Instance()->AddFileList(v->GetValue(), true, true);
}
Rule *rule = new Rule(".SUFFIXES", ".c .o .cpp .nas .asm", "", new Command("", 0), "", 0, false);
RuleList *ruleList = new RuleList(".SUFFIXES");
ruleList->Add(rule, false);
*RuleContainer::Instance() += ruleList;
std::string files = specifiedFiles.GetValue();
if (!files.size())
files = "makefile";
Include::Instance()->AddFileList(files, false, false);
SetupImplicit();
RuleContainer::Instance()->SecondaryEval();
done = !Include::Instance()->MakeMakefiles(silent.GetValue());
if (!done)
restarts++;
}
if (showDatabase.GetValue())
ShowDatabase();
int rv = 0;
if (Eval::GetErrCount())
{
rv = 2;
}
else
{
bool xsilent = silent.GetValue();
bool xignore = ignoreErrors.GetValue();
bool xdontrun = displayOnly.GetValue();
bool xtouch = touch.GetValue();
xdontrun |= xtouch || query.GetValue();
xsilent |= xtouch || query.GetValue();
Maker maker(xsilent, xdontrun, xignore, xtouch, rebuild.GetValue(), newFiles.GetValue(), oldFiles.GetValue());
for (int i = 1; i < argc; i++)
{
maker.AddGoal(argv[i]);
}
if (maker.CreateDependencyTree())
{
rv = maker.RunCommands(keepGoing.GetValue());
if (query.GetValue() && rv == 0)
rv = maker.HasCommands() ? 1 : 0;
}
else
{
rv = 2;
}
}
if (dir.GetValue().size())
{
OS::SetWorkingDir(cwd);
}
if (printDir.GetValue())
{
std::cout << OS::GetWorkingDir() << std::endl;
}
return rv;
}
static bool
makerooms(void)
{
struct rectangle *rsp;
int lx, ly, hx, hy, lowx, lowy, hix, hiy, dx, dy;
int tryct = 0, xlim, ylim;
/* init */
xlim = XLIM + secret;
ylim = YLIM + secret;
if(nroom == 0) {
rsp = rs;
rsp->rlx = rsp->rly = 0;
rsp->rhx = COLNO-1;
rsp->rhy = ROWNO-1;
rsmax = 1;
}
rscnt = rsmax;
/* make rooms until satisfied */
while(rscnt > 0 && nroom < MAXNROFROOMS-1) {
if(!secret && nroom > (MAXNROFROOMS/3) &&
!rn2((MAXNROFROOMS-nroom)*(MAXNROFROOMS-nroom)))
return(0);
/* pick a rectangle */
rsp = &rs[rn2(rscnt)];
hx = rsp->rhx;
hy = rsp->rhy;
lx = rsp->rlx;
ly = rsp->rly;
/* find size of room */
if(secret)
dx = dy = 1;
else {
dx = 2 + rn2((hx-lx-8 > 20) ? 12 : 8);
dy = 2 + rn2(4);
if(dx*dy > 50)
dy = 50/dx;
}
/* look whether our room will fit */
if(hx-lx < dx + dx/2 + 2*xlim || hy-ly < dy + dy/3 + 2*ylim) {
/* no, too small */
/* maybe we throw this area out */
if(secret || !rn2(MAXNROFROOMS+1-nroom-tryct)) {
rscnt--;
rs[rsmax] = *rsp;
*rsp = rs[rscnt];
rs[rscnt] = rs[rsmax];
tryct = 0;
} else
tryct++;
continue;
}
lowx = lx + xlim + rn2(hx - lx - dx - 2*xlim + 1);
lowy = ly + ylim + rn2(hy - ly - dy - 2*ylim + 1);
hix = lowx + dx;
hiy = lowy + dy;
if(maker(lowx, dx, lowy, dy)) {
if(secret)
return(1);
addrs(lowx-1, lowy-1, hix+1, hiy+1);
tryct = 0;
} else
if(tryct++ > 100)
break;
}
return(0); /* failed to make vault - very strange */
}
BEGIN_API
if (Reserved != NULL)
CssmError::throwMe(CSSM_ERRCODE_INVALID_POINTER);
HandleContext::Maker maker(CSPHandle);
maker.setup(Mode);
maker.setup(AccessCred);
maker.setup(Key);
maker.setup(InitVector);
maker.setup(Padding);
maker.make();
maker.put(CSSM_ATTRIBUTE_MODE, Mode);
maker.put(CSSM_ATTRIBUTE_ACCESS_CREDENTIALS, AccessCred);
maker.put(CSSM_ATTRIBUTE_KEY, Key);
maker.put(CSSM_ATTRIBUTE_INIT_VECTOR, InitVector);
maker.put(CSSM_ATTRIBUTE_PADDING, Padding);
Required(NewContextHandle) = maker(CSSM_ALGCLASS_SYMMETRIC, AlgorithmID);
END_API(CSSM)
}
CSSM_RETURN CSSMAPI
CSSM_CSP_CreateDigestContext (CSSM_CSP_HANDLE CSPHandle,
CSSM_ALGORITHMS AlgorithmID,
CSSM_CC_HANDLE *NewContextHandle)
{
BEGIN_API
HandleContext::Maker maker(CSPHandle);
maker.make();
Required(NewContextHandle) = maker(CSSM_ALGCLASS_DIGEST, AlgorithmID);
END_API(CSSM)
}
