void LinkedSortedList<T>::clear() { for(iter = getListHead(); iter != NULL; iter = iter->next) { LinkedNode<T> * tmp = iter; if(tmp) delete tmp; } setListHead(NULL); iter = getListHead(); size_ = 0; }
bool LinkedSortedList<T>::insert(LinkedNode<T> *node) { iter = getListHead(); if(!iter) { // First node becomes head. setListHead(node); #ifdef DEBUG_LIST_INSERT cout << "Insert First node. " << node->getValue().getLastName() << endl; #endif size_++; return true; } for(iter = getListHead(); iter; iter = iter->next) { if(*node <= *iter) { // node is smaller, insert in front. #ifdef DEBUG_LIST_INSERT cout << "Insert node: " << node->getValue().getLastName() << " \tbefore: " << iter->getValue().getLastName() << endl; #endif node->next = iter; node->prev = iter->prev; if(iter == getListHead()) { // insert to Head. setListHead(node); #ifdef DEBUG_LIST_INSERT cout << "Set head to: " << node->getValue().getLastName() << endl; #endif } else { // not head insert. iter->prev->next = node; // Head does not have this. } iter->prev = node; size_++; return true; } else if((*node > *iter) && (!(iter->next))) {//tail #ifdef DEBUG_LIST_INSERT cout << "Insert tail: " << node->getValue().getLastName() << " \tafter: " << iter->getValue().getLastName() << endl; #endif iter->next = node; node->prev = iter; node->next = NULL; size_++; return true; } } // while }
/// Function name : calculateGeneratorVariableIDFromName // Description : Returns the ID of the argument/variable in a ScriptGenerator with a given name. // -> If the argument/variable does not already exist, it is created // // SCRIPT_GENERATOR* pGenerator : [in] ScriptGenerator to search // CONST TCHAR* szVariable : [in] Name of the argument/variable to search for // // Return Value : One-based Variable ID // UINT calculateGeneratorVariableIDFromName(SCRIPT_GENERATOR* pGenerator, CONST TCHAR* szVariable) { VARIABLE_NAME* pVariableName; // Pre-existing VariableName or newly created VariableName /// Iterate through existing VariableNames for a match for (LIST_ITEM* pIterator = getListHead(pGenerator->pVariablesList); pIterator; pIterator = pIterator->pNext) { // Prepare pVariableName = extractListItemPointer(pIterator, VARIABLE_NAME); // [CHECK] Does current VariableName match? if (utilCompareStringVariables(pVariableName->szName, szVariable)) /// [FOUND] Return associated ID return pVariableName->iID; } /// [NOT FOUND] Create a new VariableName with a zero-based ID pVariableName = createVariableName(szVariable, getListItemCount(pGenerator->pVariablesList)); // Append to Generators's VariableNames list appendObjectToList(pGenerator->pVariablesList, (LPARAM)pVariableName); /// [FOUND] Return ID of new VariableName return pVariableName->iID; }
/// Function name : findXMLTreeNodeByName // Description : Finds a node within an XML tree by name. // // XML_TREE_NODE* pStartNode : [in] Node to start searching from // CONST TCHAR* szName : [in] Name of node to search for // CONST BOOL bRecurseChildren : [in] Whether to search child nodes recursively or just search the immediate child nodes // XML_TREE_NODE* &pOutput : [out] Desired node if found, otherwise NULL // // Return Value : TRUE if found, FALSE otherwise // BearScriptAPI BOOL findXMLTreeNodeByName(CONST XML_TREE_NODE* pStartNode, CONST TCHAR* szName, CONST BOOL bRecurseChildren, XML_TREE_NODE* &pOutput) { XML_TREE_NODE* pCurrentNode; // Node within the list item currently being processed // [CHECK] Ensure start node exists ASSERT(pStartNode != NULL); // Prepare pOutput = NULL; /// Iterate through child node list for (LIST_ITEM* pIterator = getListHead(&pStartNode->oChildren); pCurrentNode = extractListItemPointer(pIterator, XML_TREE_NODE); pIterator = pIterator->pNext) { // Check node name if (utilCompareStringVariables(pCurrentNode->szName, szName)) { /// [FOUND-DIRECT] Set result and abort pOutput = pCurrentNode; break; } /// Recurse into children else if (bRecurseChildren AND findXMLTreeNodeByName(pCurrentNode, szName, bRecurseChildren, pOutput)) /// [FOUND-INDIRECT] Abort... break; } /// Return TRUE if found, FALSE otherwise return (pOutput != NULL); }
/// Function name : findNextXMLTreeNode // Description : Retrieve the next child or sibling of a specified node // // XML_TREE_NODE* pNode : [in] The input node, this will not be altered // CONST XML_NODE_RELATIONSHIP eRelationship : [in] Whether to find the first child or first sibling node // XML_TREE_NODE* &pOutput : [out] Desired node if successful, otherwise NULL // // Return Value : TRUE if found, FALSE otherwise // BearScriptAPI BOOL findNextXMLTreeNode(CONST XML_TREE_NODE* pNode, CONST XML_NODE_RELATIONSHIP eRelationship, XML_TREE_NODE* &pOutput) { LIST_ITEM* pItem; // Prepare /*if (!pNode) return FALSE;*/ // Examine relationship switch (eRelationship) { /// [CHILD] Return first child case XNR_CHILD: // Advance to the first child of the current node (if any) if (getXMLNodeCount(pNode)) { pItem = getListHead(&pNode->oChildren); pOutput = extractListItemPointer(pItem, XML_TREE_NODE); } // [NOT FOUND] Set result to NULL else pOutput = NULL; break; /// [SIBLING] Return the next item within the list containing the input node case XNR_SIBLING: // [CHECK] Cannot perform on the root if (pNode->pItem == NULL) pOutput = NULL; // Advance to the node's next item else if (pNode->pItem->pNext) { pItem = pNode->pItem->pNext; pOutput = extractListItemPointer(pItem, XML_TREE_NODE); } // [NOT FOUND] Set result to NULL else pOutput = NULL; break; /// [PARENT] Return the input node's parent node (if any) case XNR_PARENT: pOutput = (pNode->pParent ? pNode->pParent : NULL); break; } // Return TRUE if found, FALSE otherwise return (pOutput != NULL); }
/// Function name : onDependenciesLoadSelectedScripts // Description : Loads the selected script dependencies // // PROPERTIES_DATA* pSheetData : [in] Properties sheet dialog data // HWND hPage : [in] Window handle of the dependencies page // VOID onDependenciesPage_LoadSelectedScripts(HWND hPage, SCRIPT_FILE* pScriptFile, AVL_TREE* pDependenciesTree) { SCRIPT_DEPENDENCY* pDependency; // ScriptDependency associated with the selected item LOADING_OPTIONS oOptions; // Used for highlighting caller HWND hListView; // Dependencies ListView TCHAR* szFolder; // Folder of input script LIST* pDependencyList; // List of selected ScriptDepdencies INT iSelected; // Index of the selected item /// [CHECK] Are any dependencies selected? if (ListView_GetSelectedCount(hListView = GetDlgItem(hPage, IDC_DEPENDENCIES_LIST)) == 0) return; // [VERBOSE] CONSOLE_COMMAND(); // Prepare utilZeroObject(&oOptions, LOADING_OPTIONS); pDependencyList = createList(NULL); /// Extract ScriptDependencies for selected scripts for (iSelected = ListView_GetSelected(hListView); findObjectInAVLTreeByIndex(pDependenciesTree, iSelected, (LPARAM&)pDependency); iSelected = ListView_GetNextItem(hListView, iSelected, LVNI_SELECTED)) { appendObjectToList(pDependencyList, (LPARAM)pDependency); debugScriptDependency(pDependency); } // Clear selection ListView_SetItemState(hListView, -1, NULL, LVIS_SELECTED); szFolder = utilDuplicateFolderPath(pScriptFile->szFullPath); /// Attempt to open each selected script for (LIST_ITEM* pIterator = getListHead(pDependencyList); pDependency = extractListItemPointer(pIterator, SCRIPT_DEPENDENCY); pIterator = pIterator->pNext) { //// Highlight Scriptcall on load //oOptions.bHighlight = TRUE; //StringCchCopy(oOptions.szSearchText, 256, pScriptFile->szScriptname); /// Attempt to open .pck / .xml version of script if (!commandLoadScriptDependency(getMainWindowData(), szFolder, pDependency, !pIterator->pNext, &oOptions)) // Activate the final document // [ERROR] "The script dependency '%s' could not be found in '%s'" displayMessageDialogf(hPage, IDS_GENERAL_DEPENDENCY_NOT_FOUND, MDF_OK WITH MDF_ERROR, pDependency->szScriptName, szFolder); } // Cleanup deleteList(pDependencyList); utilDeleteString(szFolder); }
/// Function name : calculateGeneratorForEachCommandCount // Description : Counts the number of existing 'for each' commands already generated. This is used for assigning unique iterator variable names // // SCRIPT_GENERATOR* pGenerator : [in] ScriptGenerator // // Return Value : Zero-based count // UINT calculateGeneratorForEachCommandCount(SCRIPT_GENERATOR* pGenerator) { COMMAND* pCommand; UINT iCount = 0; /// Iterate through standard commands for (LIST_ITEM* pIterator = getListHead(pGenerator->pOutputStream->pStandardList); pCommand = extractListItemPointer(pIterator, COMMAND); pIterator = pIterator->pNext) { // [FOR EACH IN ARRAY] Add to count if (isCommandID(pCommand, CMD_FOR_EACH)) iCount++; } // Return result return iCount; }
/// Function name : traverseXMLTree // Description : Traverse through an XML Tree, printing each node to the console // // XML_TREE_NODE* pStartNode : [in] Node to start traversal at // BearScriptAPI VOID traverseXMLTree(XML_TREE_NODE* pStartNode) { XML_TREE_NODE* pCurrentNode; // [CHECK] Ensure start node exists ASSERT(pStartNode != NULL); // Iterate through child node list for (LIST_ITEM* pIterator = getListHead(&pStartNode->oChildren); pCurrentNode = extractListItemPointer(pIterator, XML_TREE_NODE); pIterator = pIterator->pNext) { // Print tag name CONSOLE("Node: '%s' (%u properties)", pCurrentNode->szName, pCurrentNode->oProperties.iCount); // Recurse into children traverseXMLTree(pCurrentNode); } }
/// Function name : findXMLPropertyByName // Description : Search for a property within a node by name // // CONST XML_TREE_NODE* pNode : [in] Node // CONST TCHAR* szProperty : [in] Property name // XML_PROPERTY* &pOutput : [out] Property // // Return Value : TRUE/FALSE // BOOL findXMLPropertyByName(CONST XML_TREE_NODE* pNode, CONST TCHAR* szProperty, XML_PROPERTY* &pOutput) { XML_PROPERTY* pProperty; // Prepare pOutput = NULL; /// Iterate through node properties for (LIST_ITEM* pIterator = getListHead(&pNode->oProperties); !pOutput AND (pProperty = extractListItemPointer(pIterator, XML_PROPERTY)); pIterator = pIterator->pNext) { /// Determine whether property name matches if (utilCompareStringVariables(pProperty->szName, szProperty)) // [FOUND] Set result and abort pOutput = pProperty; } // Return TRUE if found return pOutput != NULL; }
bool LinkedSortedList<T>::deleteNode(LinkedNode<T> *node) { if(!node) return false; // node is NULL; // First, we need to release the node before deleting. if(getListHead() == node) { // Head node. setListHead(node->next); } else if(node->next == NULL) { node->prev->next = NULL; } else { node->prev->next = node->next; node->next->prev = node->prev; } // Now, delete node. #ifdef DEBUG_LIST_DELETE cout << "Deleted record for : " << node->getValue().getLastName() << "\t" << node->getValue().getEid() << endl; #endif delete node; size_--; return true; }
CELL * p_join(CELL * params) { char * joint = NULL; CELL * list; size_t jointLen = 0; int trailJoint = 0; params = getListHead(params, &list); if(list == nilCell) return(stuffString("")); if(list->type != CELL_STRING) return(errorProcExt(ERR_STRING_EXPECTED, list)); if(params != nilCell) { params = getStringSize(params, &joint, &jointLen, TRUE); trailJoint = getFlag(params); } return(appendString(list, list->next, joint, jointLen, trailJoint, FALSE)); }
/// Function name : isAnyDocumentModified // Description : Determines whether any document is modified // // HWND hTabCtrl : [in] Documents control // // Return Value : TRUE if there is at least one modified document, otherwise FALSE // BOOL isAnyDocumentModified(HWND hTabCtrl) { DOCUMENTS_DATA* pWindowData; // Window data DOCUMENT* pDocument; // Current document BOOL bModified; // Prepare pWindowData = getDocumentsControlData(hTabCtrl); bModified = FALSE; /// [DOCUMENTS] Iterate through document list for (LIST_ITEM* pIterator = getListHead(pWindowData->pDocumentList); !bModified AND (pDocument = extractListItemPointer(pIterator, DOCUMENT)); pIterator = pIterator->pNext) // [CHECK] Abort if document is modified... if (isModified(pDocument)) bModified = TRUE; /// [PROJECT] Check project, if any if (!bModified) bModified = isModified(getActiveProject()); // Return state return bModified; }
CELL * p_extend(CELL * params) { CELL * target; CELL * head; CELL * tail; SYMBOL * symbolRef; char * pStr; size_t size; params = getEvalDefault(params, &target); if((symbolRef = symbolCheck)) { if(isProtected(symbolRef->flags)) return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolRef))); if(isNil((CELL *)symbolRef->contents)) { deleteList((CELL*)symbolRef->contents); head = evaluateExpression(params); if(isList(head->type) || head->type == CELL_STRING) target = copyCell(head); symbolRef->contents = (UINT)target; params = params->next; } } if(isList(target->type)) { tail = (CELL *)target->aux; target->aux = (UINT)nilCell; if(tail == nilCell) { tail = (CELL *)target->contents; while(tail->next != nilCell) tail = tail->next; } while(params != nilCell) { params = getListHead(params, &head); if(head == nilCell) continue; if(target->contents == (UINT)nilCell) { target->contents = (UINT)copyList(head); tail = lastCellCopied; } else { tail->next = copyList(head); target->aux = (UINT)lastCellCopied; tail = (CELL *)target->aux; } } } else if(target->type == CELL_STRING) { while(params != nilCell) { params = getStringSize(params, &pStr, &size, TRUE); appendCellString(target, pStr, size); } } else return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, target)); symbolCheck = symbolRef; pushResultFlag = FALSE; return(target); }