void growStackCurrent (GC_state s) {
size_t reserved;
GC_stack stack;
reserved = sizeofStackGrowReserved (s, getStackCurrent(s));
if (DEBUG_STACKS or s->controls.messages)
fprintf (stderr,
"[GC: Growing stack of size %s bytes to size %s bytes, using %s bytes.]\n",
uintmaxToCommaString(getStackCurrent(s)->reserved),
uintmaxToCommaString(reserved),
uintmaxToCommaString(getStackCurrent(s)->used));
assert (hasHeapBytesFree (s, sizeofStackWithHeader (s, reserved), 0));
stack = newStack (s, reserved, TRUE);
copyStack (s, getStackCurrent(s), stack);
getThreadCurrent(s)->stack = pointerToObjptr ((pointer)stack, s->heap.start);
markCard (s, objptrToPointer (getThreadCurrentObjptr(s), s->heap.start));
}
bool
SdfCopySpec(
const SdfLayerHandle& srcLayer, const SdfPath& srcPath,
const SdfLayerHandle& dstLayer, const SdfPath& dstPath,
const SdfShouldCopyValueFn& shouldCopyValueFn,
const SdfShouldCopyChildrenFn& shouldCopyChildrenFn)
{
if (!srcLayer || !dstLayer) {
TF_CODING_ERROR("Invalid layer handle");
return false;
}
if (srcPath.IsEmpty() || dstPath.IsEmpty()) {
TF_CODING_ERROR("Invalid empty path");
return false;
}
// Validate compatible source and destination path types.
if ((srcPath.IsAbsoluteRootOrPrimPath()
|| srcPath.IsPrimVariantSelectionPath())
!= (dstPath.IsAbsoluteRootOrPrimPath()
|| dstPath.IsPrimVariantSelectionPath())
|| srcPath.IsPropertyPath() != dstPath.IsPropertyPath()
|| srcPath.IsTargetPath() != dstPath.IsTargetPath()
|| srcPath.IsMapperPath() != dstPath.IsMapperPath()
|| srcPath.IsMapperArgPath() != dstPath.IsMapperArgPath()
|| srcPath.IsExpressionPath() != dstPath.IsExpressionPath()) {
TF_CODING_ERROR("Incompatible source and destination paths");
return false;
}
// For target paths (relationship targets and connections), verify the
// destination spec already exists. See the documentation comment.
if (dstPath.IsTargetPath() && !dstLayer->HasSpec(dstPath)) {
TF_CODING_ERROR("Spec does not exist at destination target path");
return false;
}
// This function collects all of the data that will be copied for each
// spec into this list, then applies it to the layer at the very end.
// This allows us to do some analysis on the data first.
_CopyEntryList dataToCopy;
// Create a stack of source/dest copy requests, initially populated with
// the passed parameters. The copy routine will add additional requests
// as needed to handle children etc... and runs until the stack is empty.
_CopyStack copyStack(1, _CopyStackEntry(srcPath, dstPath));
while (!copyStack.empty()) {
const _CopyStackEntry toCopy = copyStack.front();
copyStack.pop_front();
// If the source path is empty, it indicates that the spec at the
// destination path should be removed. Add an entry to the queue
// to reflect that.
if (toCopy.srcPath.IsEmpty()) {
_SpecDataEntry removeEntry(toCopy.dstPath, SdfSpecTypeUnknown);
dataToCopy.push_back(removeEntry);
continue;
}
// Figure out the concrete type of the spec we're copying. The spec type
// dictates copying behavior below.
const SdfSpecType specType = srcLayer->GetSpecType(toCopy.srcPath);
if (specType == SdfSpecTypeUnknown) {
TF_CODING_ERROR("Cannot copy unknown spec at <%s> from layer <%s>",
srcPath.GetText(), srcLayer->GetIdentifier().c_str());
return false;
}
_SpecDataEntry copyEntry(toCopy.dstPath, specType);
// Determine what data is present for the current source and dest specs
// and what needs to be copied. Divide the present fields into those
// that contain values and those that index children specs.
std::vector<TfToken> dstValueFields;
std::vector<TfToken> dstChildrenFields;
_GetFieldNames(
dstLayer, toCopy.dstPath, &dstValueFields, &dstChildrenFields);
std::vector<TfToken> srcValueFields;
std::vector<TfToken> srcChildrenFields;
_GetFieldNames(
srcLayer, toCopy.srcPath, &srcValueFields, &srcChildrenFields);
// From the list of value fields, retrieve all values that the copy
// policy says we need to copy over to the destination.
_ForEachField(
srcValueFields, dstValueFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_AddFieldValueToCopy(
specType, field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyValueFn, ©Entry.dataToCopy);
});
// Add an entry for all of the data we're copying for this spec.
dataToCopy.push_back(copyEntry);
// Now add any children specs that need to be copied to our
// copy stack.
_ForEachField(
srcChildrenFields, dstChildrenFields,
[&](const TfToken& field, bool fieldInSrc, bool fieldInDst) {
_ProcessChildField(
field,
srcLayer, toCopy.srcPath, fieldInSrc,
dstLayer, toCopy.dstPath, fieldInDst,
shouldCopyChildrenFn, ©Stack);
});
}
// Now that we have all the data we want to copy, set it into the
// destination layer.
SdfChangeBlock block;
for (const _SpecDataEntry& specData : dataToCopy) {
if (specData.specType == SdfSpecTypeUnknown) {
_RemoveSpecFromLayer(dstLayer, specData);
}
else {
_AddNewSpecToLayer(dstLayer, specData);
}
for (const _FieldValuePair& fieldValue : specData.dataToCopy) {
dstLayer->SetField(
specData.dstPath, fieldValue.first, fieldValue.second);
}
}
return true;
}
/** changeDirectory: handle the change directory command
* @param c - user input (beginning with "cd ")
* @return ERROR_CODE if an error is thrown
*/
int changeDirectory(char * c) {
int result;
char path[SIZE];
memset(&path[0], 0, sizeof(path));
stripChar(c, '&');
stripEndSpace(c);
int i = 2; //jump to beginning of input path
while (c[i] == CHAR_SPACE) {
i++;
}
// changing to home, means user only wrote "cd"
if (c[i] == 0 || c[i] == '\n') {
char* homePath = getenv("HOME");
result = chdir(homePath);
if (result == 0) {//chdir worked
clearStack();
char* homeTokens;
homeTokens = strtok(homePath, "/");
//get tokens based on /
while (homeTokens != NULL) {
push(homeTokens);
homeTokens = strtok(NULL, "/");
}
}
}
//otherwise user gave more info about directory traversal
else {
stripChar(c, '\n'); //remove newline
strtok(c, " "); //skip to path characters
char * token[SIZE];
int z = 0;
token[z] = strtok(NULL, "/");
//get tokens based on /
while (token[z] != NULL) {
z++;
token[z] = strtok(NULL, "/");
}
//this means an absolute path
if (strncmp(home, token[0], 4) == 0) {
strcat(path, "/");
int p = 0;
for (; p < z; p++) {
strcat(path, token[p]);
strcat(path, "/");
}
result = chdir(path);
if (result == 0) {
clearStack();
int v = 0;
for (; v < z; v++) {
push(token[v]);
}
} else {
return throwError();
}
}
// relative path
else {
copyStack(); //save the stack state of path
bool root = false;
int f = 0;
for (; f <z; f++) {
if (strncmp(dotdot, token[f], 2) == 0) {
// user tries to traverse past root
if (stackPointer == 0) {
root = true;
break;
} else {
pop();
}
} else {
push(token[f]);
}
}
// user has not gone past root
if (!root) {
strcat(path, "/");
int p = 0;
for (; p < stackPointer; p++) {
strcat(path, pathStack[p]);
strcat(path, "/");
}
result = chdir(path);
if (result != 0) {
replaceStack();
return throwError();
}
}
// user goes past root, in command, so reload stack
else {
replaceStack();
return throwError();
}
}
}
return SUCCESS;
}
