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; }