summaryrefslogtreecommitdiffstats
path: root/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp')
-rw-r--r--debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp659
1 files changed, 659 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp
new file mode 100644
index 00000000..72cbc29d
--- /dev/null
+++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/align_stack.cpp
@@ -0,0 +1,659 @@
+/**
+ * @file align_stack.cpp
+ * Manages an align stack, which is just a pair of chunk stacks.
+ * There can be at most 1 item per line in the stack.
+ * The seqnum is actually a line counter.
+ *
+ * @author Ben Gardner
+ * @license GPL v2+
+ */
+
+#include "align_stack.h"
+
+#include "align_tab_column.h"
+#include "indent.h"
+#include "space.h"
+#include "unc_tools.h" // to get stackID and get_A_Number()
+
+
+constexpr static auto LCURRENT = LAS;
+
+using namespace uncrustify;
+
+using std::numeric_limits;
+
+
+void AlignStack::Start(size_t span, int thresh)
+{
+ stackID = get_A_Number(); // for debugging purpose only
+
+ // produces much more log output. Use it only debugging purpose
+ // WITH_STACKID_DEBUG;
+
+ //LOG_FMT(LAS, "AlignStack::Start(%d):m_aligned.Reset()\n", __LINE__);
+ m_aligned.Reset();
+ //LOG_FMT(LAS, "AlignStack::Start(%d):m_skipped.Reset()\n", __LINE__);
+ m_skipped.Reset();
+
+ if (thresh >= 0)
+ {
+ m_absolute_thresh = false;
+ m_thresh = thresh;
+ }
+ else
+ {
+ m_absolute_thresh = true;
+ m_thresh = -thresh;
+ }
+ m_span = span;
+ m_min_col = numeric_limits<size_t>::max();
+ m_max_col = 0;
+ m_nl_seqnum = 0;
+ m_seqnum = 0;
+ m_gap = 0;
+ m_right_align = false;
+ m_star_style = SS_IGNORE;
+ m_amp_style = SS_IGNORE;
+} // AlignStack::Start
+
+
+void AlignStack::ReAddSkipped()
+{
+ // produces much more log output. Use it only debugging purpose
+ // WITH_STACKID_DEBUG;
+
+ if (m_skipped.Empty())
+ {
+ return;
+ }
+ // Make a copy of the ChunkStack and clear m_skipped
+ m_scratch.Set(m_skipped);
+ //LOG_FMT(LAS, "AlignStack::ReAddSkipped(%d):m_skipped.Reset()\n", __LINE__);
+ m_skipped.Reset();
+
+ // Need to add them in order so that m_nl_seqnum is correct
+ for (size_t idx = 0; idx < m_scratch.Len(); idx++)
+ {
+ const ChunkStack::Entry *ce = m_scratch.Get(idx);
+ LOG_FMT(LAS, "AlignStack::ReAddSkipped [%zu] - ", ce->m_seqnum);
+ Add(ce->m_pc, ce->m_seqnum);
+ }
+
+ NewLines(0); // Check to see if we need to flush right away
+} // AlignStack::ReAddSkipped
+
+
+void AlignStack::Add(Chunk *start, size_t seqnum)
+{
+ // produces much more log output. Use it only debugging purpose
+ // WITH_STACKID_DEBUG;
+ LOG_FUNC_ENTRY();
+
+ LOG_FMT(LAS, "AlignStack::%s(%d): Candidate '%s': orig line %zu, column %zu, type %s, level %zu\n",
+ __func__, __LINE__, start->Text(), start->GetOrigLine(), start->GetColumn(), get_token_name(start->GetType()), start->GetLevel());
+ LOG_FMT(LAS, "AlignStack::%s(%d): seqnum %zu m_seqnum %zu\n", __func__, __LINE__, seqnum, m_seqnum);
+
+ // Assign a seqnum if needed
+ if (seqnum == 0)
+ {
+ seqnum = m_seqnum;
+ }
+ m_last_added = 0;
+
+ // Threshold check should begin after
+ // tighten down the spacing between ref and start
+
+ /*
+ * SS_IGNORE: no special handling of '*' or '&', only 'foo' is aligned
+ * void foo; // gap=5, 'foo' is aligned
+ * char * foo; // gap=3, 'foo' is aligned
+ * foomatic foo; // gap=1, 'foo' is aligned
+ * The gap is the columns between 'foo' and the previous token.
+ * [void - foo], ['*' - foo], etc
+ *
+ * SS_INCLUDE: - space between variable and '*' or '&' is eaten
+ * void foo; // gap=5, 'foo' is aligned
+ * char *foo; // gap=5, '*' is aligned
+ * foomatic foo; // gap=1, 'foo' is aligned
+ * The gap is the columns between the first '*' or '&' before foo
+ * and the previous token. [void - foo], [char - '*'], etc
+ *
+ * SS_DANGLE: - space between variable and '*' or '&' is eaten
+ * void foo; // gap=5
+ * char *bar; // gap=5, as the '*' doesn't count
+ * foomatic foo; // gap=1
+ * The gap is the columns between 'foo' and the chunk before the first
+ * '*' or '&'. [void - foo], [char - bar], etc
+ *
+ * If the gap < m_gap, then the column is bumped out by the difference.
+ * So, if m_gap is 2, then the above would be:
+ * SS_IGNORE:
+ * void foo; // gap=6
+ * char * foo; // gap=4
+ * foomatic foo; // gap=2
+ * SS_INCLUDE:
+ * void foo; // gap=6
+ * char *foo; // gap=6
+ * foomatic foo; // gap=2
+ * SS_DANGLE:
+ * void foo; // gap=6
+ * char *bar; // gap=6, as the '*' doesn't count
+ * foomatic foo; // gap=2
+ * Right aligned numbers:
+ * #define A -1
+ * #define B 631
+ * #define C 3
+ * Left aligned numbers:
+ * #define A -1
+ * #define B 631
+ * #define C 3
+ *
+ * In the code below, pc is set to the item that is aligned.
+ * In the above examples, that is 'foo', '*', '-', or 63.
+ *
+ * Ref is set to the last part of the type.
+ * In the above examples, that is 'void', 'char', 'foomatic', 'A', or 'B'.
+ *
+ * The '*' and '&' can float between the two.
+ *
+ * If align_on_tabstop=true, then SS_DANGLE is changed to SS_INCLUDE.
+ */
+
+ if ( options::align_on_tabstop()
+ && m_star_style == SS_DANGLE)
+ {
+ m_star_style = SS_INCLUDE;
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%d): m_star_style is %s\n",
+ __func__, __LINE__, get_StarStyle_name(m_star_style));
+ // Find ref. Back up to the real item that is aligned.
+ Chunk *prev = start->GetPrev();
+
+ while ( prev->IsPointerOperator()
+ || prev->Is(CT_TPAREN_OPEN))
+ {
+ prev = prev->GetPrev();
+ }
+
+ if (prev->IsNullChunk())
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): 'ref' chunk not found. Do not add.\n",
+ __func__, __LINE__);
+ return;
+ }
+ Chunk *ref = prev;
+
+ if (ref->IsNewline())
+ {
+ ref = ref->GetNext();
+ }
+ // Find the item that we are going to align.
+ Chunk *ali = start;
+
+ if (m_star_style != SS_IGNORE)
+ {
+ // back up to the first '*' or '^' preceding the token
+ Chunk *tmp_prev = ali->GetPrev();
+
+ while ( tmp_prev->IsStar()
+ || tmp_prev->IsMsRef())
+ {
+ ali = tmp_prev;
+ tmp_prev = ali->GetPrev();
+ }
+
+ if (tmp_prev->Is(CT_TPAREN_OPEN))
+ {
+ ali = tmp_prev;
+ tmp_prev = ali->GetPrev();
+ // this is correct, even Coverity says:
+ // CID 76021 (#1 of 1): Unused value (UNUSED_VALUE)returned_pointer: Assigning value from
+ // ali->GetPrev(nav_e::ALL) to prev here, but that stored value is overwritten before it can be used.
+ }
+ }
+
+ if (m_amp_style != SS_IGNORE)
+ {
+ // back up to the first '&' preceding the token
+ Chunk *tmp_prev = ali->GetPrev();
+
+ while (tmp_prev->IsAddress())
+ {
+ ali = tmp_prev;
+ tmp_prev = ali->GetPrev();
+ }
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'ref' orig line %zu, orig col %zu, text '%s', level %zu, type %s\n",
+ __func__, __LINE__, ref->GetOrigLine(), ref->GetOrigCol(), ref->Text(), ref->GetLevel(), get_token_name(ref->GetType()));
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'ali' orig line %zu, orig col %zu, text '%s', level %zu, type %s\n",
+ __func__, __LINE__, ali->GetOrigLine(), ali->GetOrigCol(), ali->Text(), ali->GetLevel(), get_token_name(ali->GetType()));
+ log_rule_B("align_keep_extra_space");
+
+ // Tighten down the spacing between ref and start
+ if (!options::align_keep_extra_space())
+ {
+ size_t tmp_col = ref->GetColumn();
+ Chunk *tmp = ref;
+ LOG_FMT(LAS, "AlignStack::%s(%3d): tmp_col is %zu\n",
+ __func__, __LINE__, tmp_col);
+
+ while ( tmp->IsNotNullChunk()
+ && tmp != start)
+ {
+ Chunk *next = tmp->GetNext();
+
+ if (next->IsNotNullChunk())
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'next' orig line %zu, orig col %zu, text '%s', level %zu, type %s\n",
+ __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), next->Text(), next->GetLevel(), get_token_name(next->GetType()));
+ tmp_col += space_col_align(tmp, next);
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'next' column %zu, level %zu, tmp_col %zu\n",
+ __func__, __LINE__, next->GetColumn(), next->GetLevel(), tmp_col);
+
+ if (next->GetColumn() != tmp_col)
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%3d): call align_to_column\n", __func__, __LINE__);
+ align_to_column(next, tmp_col);
+ }
+ }
+ tmp = next;
+ }
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%3d): m_min_col %zu, m_max_col %zu, start_col %zu, m_thresh %zu, m_gap %zu\n",
+ __func__, __LINE__, m_min_col, m_max_col, start->GetColumn(), m_thresh, m_gap);
+
+ // Check threshold limits
+ if ( m_max_col == 0
+ || m_thresh == 0
+ || ( ((start->GetColumn() + m_gap) <= (m_thresh + (m_absolute_thresh ? m_min_col : m_max_col))) // don't use subtraction here to prevent underflow
+ && ( (start->GetColumn() + m_gap + m_thresh) >= m_max_col // change the expression to mind negative expression
+ || start->GetColumn() >= m_min_col)))
+ {
+ // we are adding it, so update the newline seqnum
+ if (seqnum > m_nl_seqnum)
+ {
+ m_nl_seqnum = seqnum;
+ }
+ // Set the column adjust and gap
+ size_t col_adj = 0; // Amount the column is shifted for 'dangle' mode
+ size_t gap = 0;
+
+ if (ref != ali)
+ {
+ gap = ali->GetColumn() - (ref->GetColumn() + ref->Len());
+ }
+ Chunk *tmp = ali;
+
+ if (tmp->Is(CT_TPAREN_OPEN))
+ {
+ tmp = tmp->GetNext();
+ }
+
+ if ( ( tmp->IsStar()
+ && m_star_style == SS_DANGLE)
+ || ( tmp->IsAddress()
+ && m_amp_style == SS_DANGLE)
+ || ( tmp->IsNullable()
+ && (m_star_style == SS_DANGLE))
+ || ( tmp->IsMsRef()
+ && m_star_style == SS_DANGLE)) // TODO: add m_msref_style
+ {
+ col_adj = start->GetColumn() - ali->GetColumn();
+ gap = start->GetColumn() - (ref->GetColumn() + ref->Len());
+ }
+ // See if this pushes out the max_col
+ const size_t endcol = ali->GetColumn() + col_adj
+ + (gap < m_gap ? m_gap - gap : 0);
+
+ ali->AlignData().col_adj = col_adj;
+ ali->AlignData().ref = ref;
+ ali->AlignData().start = start;
+ m_aligned.Push_Back(ali, seqnum);
+ m_last_added = 1;
+
+ // Issue #2278
+ if (ali->Is(CT_PTR_TYPE))
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): add [%s][%s]: 'ali' orig line %zu, column %zu, type %s, level %zu\n",
+ __func__, __LINE__, ali->Text(), start->Text(), ali->GetOrigLine(), ali->GetColumn(), get_token_name(ali->GetType()), ali->GetLevel());
+ }
+ else
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%3d): add [%s]: 'ali' orig line %zu, column %zu, type %s, level %zu\n",
+ __func__, __LINE__, ali->Text(), ali->GetOrigLine(), ali->GetColumn(), get_token_name(ali->GetType()), ali->GetLevel());
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'ali' alignment col_adj %d, ref '%s', endcol %zu\n",
+ __func__, __LINE__, ali->GetAlignData().col_adj, ref->Text(), endcol);
+
+ if (m_min_col > endcol)
+ {
+ m_min_col = endcol;
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%3d): add aligned: seqnum %zu, m_nl_seqnum %zu, m_seqnum %zu\n",
+ __func__, __LINE__, seqnum, m_nl_seqnum, m_seqnum);
+ LOG_FMT(LAS, "AlignStack::%s(%3d): 'ali' orig line %zu, column %zu, m_min_col %zu, max_col old/new %zu/%zu\n",
+ __func__, __LINE__, ali->GetOrigLine(), ali->GetColumn(), m_min_col, m_max_col, endcol);
+
+ if (endcol > m_max_col)
+ {
+ m_max_col = endcol;
+
+ /*
+ * If there were any entries that were skipped, re-add them as they
+ * may now be within the threshold
+ */
+ if (!m_skipped.Empty())
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%3d): ReAddSkipped()\n", __func__, __LINE__);
+ ReAddSkipped();
+ }
+ }
+ }
+ else
+ {
+ // The threshold check failed, so add it to the skipped l
+ m_skipped.Push_Back(start, seqnum);
+ m_last_added = 2;
+
+ LOG_FMT(LAS, "AlignStack::add skipped [%zu/%zu/%zu]: line %zu, col %zu <= %zu + %zu\n",
+ seqnum, m_nl_seqnum, m_seqnum,
+ start->GetOrigLine(), start->GetColumn(), m_max_col, m_thresh);
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%3d): end of add\n", __func__, __LINE__);
+ // produces much more log output. Use it only debugging purpose
+} // AlignStack::Add
+
+
+void AlignStack::NewLines(size_t cnt)
+{
+ // produces much more log output. Use it only debugging purpose
+ // WITH_STACKID_DEBUG;
+
+ if (m_aligned.Empty())
+ {
+ //LOG_FMT(LAS, "AlignStack::Newlines(%d): nothing to do, empty\n", __LINE__);
+ return;
+ }
+ LOG_FMT(LAS, "AlignStack::Newlines(%d): cnt %zu\n", __LINE__, cnt);
+ m_seqnum += cnt;
+ LOG_FMT(LAS, "AlignStack::Newlines(%d): m_seqnum %zu, m_nl_seqnum %zu, m_span %zu\n",
+ __LINE__, m_seqnum, m_nl_seqnum, m_span);
+
+ if (m_seqnum > (m_nl_seqnum + m_span))
+ {
+ LOG_FMT(LAS, "AlignStack::Newlines(%d): cnt %zu\n", __LINE__, cnt);
+ Flush();
+ }
+} // AlignStack::NewLines
+
+
+void AlignStack::Flush()
+{
+ // produces much more log output. Use it only debugging purpose
+ // WITH_STACKID_DEBUG;
+
+ LOG_FMT(LAS, "AlignStack::%s(%d): Len() is %zu\n",
+ __func__, __LINE__, Len());
+
+ if (Len() > 0)
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): min is %zu, max is %zu\n",
+ __func__, __LINE__, m_min_col, m_max_col);
+ }
+ else
+ {
+ return;
+ }
+
+ if (Len() == 1)
+ {
+ // check if we have *one* typedef in the line
+ Chunk *pc = m_aligned.Get(0)->m_pc;
+ Chunk *temp = pc->GetPrevType(CT_TYPEDEF, pc->GetLevel());
+
+ if (temp->IsNotNullChunk())
+ {
+ if (pc->GetOrigLine() == temp->GetOrigLine())
+ {
+ // reset the gap only for *this* stack
+ m_gap = 1;
+ }
+ }
+ }
+ m_last_added = 0;
+ m_max_col = 0;
+
+ // produces much more log output. Use it only debugging purpose
+ LOG_FMT(LAS, "AlignStack::%s(%d): Debug the stack, Len() is %zu\n",
+ __func__, __LINE__, Len());
+
+ for (size_t idx = 0; idx < Len(); idx++)
+ {
+ Chunk *pc = m_aligned.Get(idx)->m_pc;
+ LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, pc->Text() is '%s', orig line is %zu, orig col is %zu, alignment col_adj is %d\n",
+ __func__, __LINE__, idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetAlignData().col_adj);
+ }
+
+ // Recalculate the max_col - it may have shifted since the last Add()
+ for (size_t idx = 0; idx < Len(); idx++)
+ {
+ Chunk *pc = m_aligned.Get(idx)->m_pc;
+
+ // Set the column adjust and gap
+ size_t col_adj = 0;
+ size_t gap = 0;
+
+ if (pc != pc->GetAlignData().ref)
+ {
+ gap = pc->GetColumn() - (pc->GetAlignData().ref->GetColumn() + pc->GetAlignData().ref->Len());
+ }
+
+ if (m_star_style == SS_DANGLE)
+ {
+ Chunk *tmp = (pc->Is(CT_TPAREN_OPEN)) ? pc->GetNext() : pc;
+
+ if (tmp->IsPointerOperator())
+ {
+ col_adj = pc->GetAlignData().start->GetColumn() - pc->GetColumn();
+ gap = pc->GetAlignData().start->GetColumn() - (pc->GetAlignData().ref->GetColumn() + pc->GetAlignData().ref->Len());
+ }
+ }
+
+ if (m_right_align)
+ {
+ // Adjust the width for signed numbers
+ if (pc->GetAlignData().start->IsNotNullChunk())
+ {
+ size_t start_len = pc->GetAlignData().start->Len();
+
+ if (pc->GetAlignData().start->GetType() == CT_NEG)
+ {
+ Chunk *next = pc->GetAlignData().start->GetNext();
+
+ if (next->Is(CT_NUMBER))
+ {
+ start_len += next->Len();
+ }
+ }
+ col_adj += start_len;
+ }
+ }
+ pc->AlignData().col_adj = col_adj;
+
+ // See if this pushes out the max_col
+ const size_t endcol = pc->GetColumn() + col_adj
+ + (gap < m_gap ? m_gap - gap : 0);
+
+ if (endcol > m_max_col)
+ {
+ m_max_col = endcol;
+ }
+ }
+
+ log_rule_B("align_on_tabstop");
+
+ if ( options::align_on_tabstop()
+ && Len() > 1)
+ {
+ m_max_col = align_tab_column(m_max_col);
+ }
+ LOG_FMT(LAS, "AlignStack::%s(%d): Debug the stack, Len() is %zu\n",
+ __func__, __LINE__, Len());
+
+ for (size_t idx = 0; idx < Len(); idx++)
+ {
+ Chunk *pc = m_aligned.Get(idx)->m_pc;
+ LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, pc->Text() is '%s', orig line is %zu, orig col is %zu, alignment col_adj is %d\n",
+ __func__, __LINE__, idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), pc->GetAlignData().col_adj);
+ }
+
+ const ChunkStack::Entry *ce = nullptr;
+
+ for (size_t idx = 0; idx < Len(); idx++)
+ {
+ ce = m_aligned.Get(idx);
+ Chunk *pc = ce->m_pc;
+
+ const size_t tmp_col = m_max_col - pc->GetAlignData().col_adj;
+
+ if (idx == 0)
+ {
+ if ( m_skip_first
+ && pc->GetColumn() != tmp_col)
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): orig line is %zu, orig col is %zu, dropping first item due to skip_first\n",
+ __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol());
+ m_skip_first = false;
+ m_aligned.Pop_Front();
+ Flush();
+ m_skip_first = true;
+ return;
+ }
+ pc->SetFlagBits(PCF_ALIGN_START);
+
+ pc->AlignData().right_align = m_right_align;
+ pc->AlignData().amp_style = m_amp_style;
+ pc->AlignData().star_style = m_star_style;
+ }
+ pc->AlignData().gap = m_gap;
+ pc->AlignData().next = m_aligned.GetChunk(idx + 1);
+
+ // Indent the token, taking col_adj into account
+ LOG_FMT(LAS, "AlignStack::%s(%d): orig line is %zu, orig col is %zu, Text() '%s', set to col %zu (adj is %d)\n",
+ __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), tmp_col, pc->GetAlignData().col_adj);
+ align_to_column(pc, tmp_col);
+ }
+
+ size_t last_seqnum = 0;
+
+ if (ce != nullptr)
+ {
+ last_seqnum = ce->m_seqnum;
+ //LOG_FMT(LAS, "AlignStack::Flush(%d):m_aligned.Reset()\n", __LINE__);
+ m_aligned.Reset();
+ }
+ m_min_col = numeric_limits<size_t>::max(); // use unrealistic high numbers
+ m_max_col = 0; // as start value
+
+ if (m_skipped.Empty())
+ {
+ // Nothing was skipped, sync the sequence numbers
+ m_nl_seqnum = m_seqnum;
+ }
+ else
+ {
+ // Remove all items with seqnum < last_seqnum
+ for (size_t idx = 0; idx < m_skipped.Len(); idx++)
+ {
+ if (m_skipped.Get(idx)->m_seqnum < last_seqnum)
+ {
+ m_skipped.Zap(idx);
+ }
+ }
+
+ m_skipped.Collapse();
+
+ ReAddSkipped(); // Add all items from the skipped list
+ }
+} // AlignStack::Flush
+
+
+void AlignStack::Reset()
+{
+ // WITH_STACKID_DEBUG;
+ //LOG_FMT(LAS, "AlignStack::Reset(%d):m_aligned.Reset()\n", __LINE__);
+ m_aligned.Reset();
+ //LOG_FMT(LAS, "AlignStack::Reset(%d):m_skipped.Reset()\n", __LINE__);
+ m_skipped.Reset();
+} // AlignStack::Reset
+
+
+void AlignStack::End()
+{
+ // WITH_STACKID_DEBUG;
+
+ if (!m_aligned.Empty())
+ {
+ //LOG_FMT(LAS, "AlignStack::End(%d):\n", __LINE__);
+ Flush();
+ }
+ //LOG_FMT(LAS, "AlignStack::End(%d):m_aligned.Reset()\n", __LINE__);
+ m_aligned.Reset();
+ //LOG_FMT(LAS, "AlignStack::End(%d):m_skipped.Reset()\n", __LINE__);
+ m_skipped.Reset();
+} // AlignStack::End
+
+
+size_t AlignStack::Len()
+{
+ // WITH_STACKID_DEBUG;
+ return(m_aligned.Len());
+} // AlignStack::Len
+
+
+void AlignStack::Debug()
+{
+ // WITH_STACKID_DEBUG;
+
+ size_t length = Len();
+
+ if (length > 0)
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): Debug the stack, Len is %zu\n",
+ __func__, __LINE__, Len());
+
+ for (size_t idx = 0; idx < length; idx++)
+ {
+ Chunk *pc = m_aligned.Get(idx)->m_pc;
+
+ if (pc->Is(CT_PTR_TYPE))
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, [%s][%s]: orig line is %zu, orig col is %zu, type is %s, level is %zu, brace level is %zu\n",
+ __func__, __LINE__, idx, pc->Text(), pc->GetNext()->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetLevel(), pc->GetBraceLevel());
+ }
+ else
+ {
+ LOG_FMT(LAS, "AlignStack::%s(%d): idx is %zu, [%s]: orig line is %zu, orig col is %zu, type is %s, level is %zu, brace level is %zu\n",
+ __func__, __LINE__, idx, pc->Text(), pc->GetOrigLine(), pc->GetOrigCol(), get_token_name(pc->GetType()), pc->GetLevel(), pc->GetBraceLevel());
+ }
+ }
+ }
+} // AlignStack::Debug
+
+
+const char *AlignStack::get_StarStyle_name(StarStyle star_style)
+{
+ // WITH_STACKID_DEBUG;
+ switch (star_style)
+ {
+ case StarStyle::SS_IGNORE:
+ return("SS_IGNORE");
+
+ case StarStyle::SS_INCLUDE:
+ return("SS_INCLUDE");
+
+ case StarStyle::SS_DANGLE:
+ return("SS_DANGLE");
+ }
+ return("?????");
+} // AlignStack::get_StarStyle_name