From 709821ff55b2f6fc8e7b4271d091fd8457083865 Mon Sep 17 00:00:00 2001 From: Benny Baumann Date: Wed, 2 Dec 2020 08:08:35 +0100 Subject: Some minor spelling issues --- ProcessList.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/ProcessList.c b/ProcessList.c index ada0451a..250e85ec 100644 --- a/ProcessList.c +++ b/ProcessList.c @@ -148,8 +148,8 @@ int ProcessList_size(ProcessList* this) { // // The algorithm is based on `depth-first search`, // even though `breadth-first search` approach may be more efficient on first glance, -// after comparision it may be not, as it's not save to go deeper without first updating the tree structure. -// If it would be save that approach would likely bring an advantage in performance. +// after comparision it may be not, as it's not safe to go deeper without first updating the tree structure. +// If it would be safe that approach would likely bring an advantage in performance. // // Each call of the function looks for a 'layer'. A 'layer' is a list of processes with the same depth. // First it sorts a list. Then it runs the function recursively for each element of the sorted list. @@ -157,26 +157,28 @@ int ProcessList_size(ProcessList* this) { // // It relies on `leftBound` and `rightBound` as an optimization to cut the list size at the time it builds a 'layer'. // -// It uses a temporary Hashtable `draftingTreeSet` because it's not save to traverse a tree +// It uses a temporary Hashtable `draftingTreeSet` because it's not safe to traverse a tree // and at the same time make changes in it. +// static void ProcessList_updateTreeSetLayer(ProcessList* this, unsigned int leftBound, unsigned int rightBound, unsigned int deep, unsigned int left, unsigned int right, unsigned int* index, unsigned int* treeIndex, int indent) { - // It's guaranted that layer_size is enough space + + // It's guaranteed that layer_size is enough space // but most likely it needs less. Specifically on first iteration. int layerSize = (right - left) / 2; - // check if we reach `children` of `leafes` + // check if we reach `children` of `leaves` if (layerSize == 0) return; Vector* layer = Vector_new(this->processes->type, false, layerSize); // Find all processes on the same layer (process with the same `deep` value - // and included in a range from `leftBound` to `rightBound`. + // and included in a range from `leftBound` to `rightBound`). // // This loop also keeps track of left_bound and right_bound of these processes // in order not to lose this information once the list is sorted. // - // The variables left_bound and right_bound are different from what the values lhs and rhs represent, + // The variables left_bound and right_bound are different from what the values lhs and rhs represent. // While left_bound and right_bound define a range of processes to look at, the values given by lhs and rhs are indices into an array // // In the below example note how filtering a range of indices i is different from filtering for processes in the bounds left_bound < x < right_bound … @@ -197,7 +199,7 @@ static void ProcessList_updateTreeSetLayer(ProcessList* this, unsigned int leftB // Make a 'right_bound' of previous_process in a layer the current process's index. // // Use 'tree_depth' as a temporal variable. - // it is save to do as later 'tree_depth' will be renovated. + // It's safe to do as later 'tree_depth' will be renovated. previous_process->tree_depth = proc->tree_index; } @@ -205,8 +207,8 @@ static void ProcessList_updateTreeSetLayer(ProcessList* this, unsigned int leftB } } - // The loop above changes process-1 so the last process on the layer - // isn't updated by the that loop. + // The loop above changes just up to process-1. + // So the last process of the layer isn't updated by the above code. // // Thus, if present, set the `rightBound` to the last process on the layer if (Vector_size(layer) > 0) { -- cgit v1.2.3