static void PrintTree (DirEntry_s *direntry, int indent)
{
	if (!direntry) return;
	if (Option.print) {
		Indent(indent);
		printf("%s %s\n", direntry->type == T_DIR ? "D" : "F",
			direntry->name);
	}
	PrintTree(direntry->child, indent + 1);
	PrintTree(direntry->sibling, indent);
}

void PicturePrinter::SetFontSpacing(int32 spacing) { 
	Indent(); Print("SetFontSpacing"); 
	switch(spacing) {
		case B_CHAR_SPACING: Print("B_CHAR_SPACING"); break;
		case B_STRING_SPACING: Print("B_STRING_SPACING"); break;
		case B_BITMAP_SPACING: Print("B_BITMAP_SPACING"); break;
		case B_FIXED_SPACING: Print("B_FIXED_SPACING"); break;
		default: Print("Unknown: ", (float)spacing);
	}
	Cr();
}

static TRI_aql_node_t* DumpStatementStart (TRI_aql_statement_walker_t* const walker,
                                           TRI_aql_node_t* const node) {
  if (node == NULL) {
    return node;
  }

  assert(walker);
  Indent((TRI_aql_dump_t*) walker->_data);

  return DumpNode(walker, node);
}

 // Update current position, printing it if it's significantly different
 // from the previous position.
 void PrintPos(IRInst* inst, unsigned int indent)
 {
     const IRPos& newPos = inst->GetPos();
     if (newPos.GetFile() != mLastPos.GetFile() ||
         newPos.GetLine() > mLastPos.GetLine() + 5 ||
         newPos.GetLine() < mLastPos.GetLine()) {
         Indent(indent) << "#line " << newPos.GetLine() << " "
                        << '"' << newPos.GetFile() << '"' << "\n";
     }
     mLastPos = newPos;
 }

void MP4Integer64Property::Dump(FILE* pFile, u_int8_t indent,
	bool dumpImplicits, u_int32_t index)
{
	if (m_implicit && !dumpImplicits) {
		return;
	}
	Indent(pFile, indent);
	fprintf(pFile, 
		"%s = "U64" (0x%016"X64F")\n", 
		m_name, m_values[index], m_values[index]);
}

void XmlWriter::WriteVector(const std::vector<T>& val) {
	Indent();
	typename std::vector<T>::const_iterator it;
	bool first = true;
	for (it = val.begin(); it != val.end(); it++) {
		if (!first)
			stream.put(' ');
		first = false;
		Write<T>(*it);
	}
}

 void SaveStart(char const* name)
 {
     if (name == 0) return;
     if(m_depth > 0){
         this->This()->Save("\n");
         Indent();
     }
     ++m_depth;
     this->This()->Save("[");
     this->This()->Save(name);
     this->This()->Save("]:");
 }

		void AstIfStatement::PrintInternal(ostream& o, int indentation)
		{
			o << Indent(indentation) << "if (";
			condition->Print(o, indentation, shared_from_this());
			o << endl;
			trueBranch->Print(o, indentation + 1, shared_from_this());
			if (falseBranch)
			{
				o << endl;
				falseBranch->Print(o, indentation + 1, shared_from_this());
			}
		}

//---------------------------------------------------------
DocumentXML& DocumentXML::toParent() {
  assert(NodeStack.size() > 1 && "too much backtracking");

  if (HasCurrentNodeSubNodes) {
    Indent();
    Out << "</" << NodeStack.top() << ">\n";
  } else
    Out << "/>\n";
  NodeStack.pop();
  HasCurrentNodeSubNodes = true;
  return *this;
}

void ChunkHModelNode(BYTE *data, DWORD size)
{
    W3dHModelNodeStruct *node = (W3dHModelNodeStruct *) data;

    int num_nodes = size / sizeof(W3dHModelNodeStruct);

    for (int i=0; i<num_nodes; i++)
    {
        printf("HModelNode.Name: \"%s\"\n", node->RenderObjName);
        fprintf(outf,"%sHModelNode.Name: \"%s\"\n", Indent(), node->RenderObjName);
    }
}

void	CameraRange::Process( uint32_t inStartOffset,
										uint32_t inEndOffset )
{
	if (inEndOffset != inStartOffset + 8)
	{
		throw DataLengthException( Name(), inStartOffset, inEndOffset, 8 );
	}
	
	Out() << Indent() << Name() << " ( " <<
		FetchFloat32( inStartOffset ) << " " <<
		FetchFloat32( inStartOffset+4 ) << " )\n";
}

void CXMLExporterBase::Write(const char* lpszFormat, ...)
{
    va_list argList;
    va_start(argList, lpszFormat);

    Indent();

    // Write the data
    vfprintf(m_pFile, lpszFormat, argList);

    va_end(argList);
}

	void StartElement(PCWSTR name)
	{
		if(!m_isTagClosed)
		{
			m_stream << ">\r\n";
		}
		Indent(m_stack.size());
		m_stream << '<' << name;
		m_stack.push_back(string(name));
		m_isTagClosed = false;
		m_hasChild = false;
	}

void ChunkPivot(BYTE *data, DWORD size)
{
    W3dPivotStruct *pivot = (W3dPivotStruct *) data;

    int num_pivots = size / sizeof(W3dPivotStruct);

    for (int i=0; i<num_pivots; i++)
    {
        printf("Pivot.Name: \"%s\"\n", pivot[i].Name);
        fprintf(outf,"%sPivot.Name: \"%s\"\n", Indent(), pivot[i].Name);
    }
}

		FunctionLogger(const char *name, const char *fmt=NULL, ...) : mName(name) {
			Indent();
			printf("-> %s ", name);
			if (fmt) {
				va_list args;
				va_start(args, fmt);
				vprintf(fmt, args);
				va_end(args);
			}
			printf("\n");
			++sIndent;
		}

void
SystemOutputUsageFormatter::FormatArgument( const std::string& primaryName, bool hasVariableParameterCount, int maxArgumentCount, const std::vector<std::string>& aliases, const std::vector<std::string>& dependencyNames, const std::string& description )
{
    myUsage << std::endl << Indent() << primaryName;

    if( aliases.size() > 0 ) {
        bool firstAlias = true;
        myUsage << " (";
        for( auto& alias : aliases ) {
            if( !firstAlias ) {
                myUsage << ", ";
            }
            firstAlias = false;
            myUsage << alias;
        }
        myUsage << ")";
    }

    if( maxArgumentCount == Constructor::NO_PARAMETER_LIMIT ) {
        myUsage << " <arg1> ... <argN>";
    }
    else if( hasVariableParameterCount ) {
        for( int i = 0; i < maxArgumentCount; ++i ) {
            myUsage << (i == 0 ? "" : " ");
            myUsage << " <arg" << (i + 1) << ">";
        }
    }

    myUsage << std::endl << Indent() << Indent() << description;

    if( dependencyNames.size() > 0 ) {
        myUsage << std::endl << Indent() << Indent() << "Dependencies:";
        for( size_t i = 0; i < dependencyNames.size(); ++i ) {
            myUsage << (i == 0 ? "" : ", " );
            myUsage << dependencyNames[i];
        }

        myUsage << std::endl;
    }
}

ZString ValueList::GetString(int indent)
{
    // [ args ]

    ZString str = "[\n";

    m_iter.First();

    while (!m_iter.End()) {
        str += Indent(indent + 1) + m_iter.Value()->GetChildString(indent + 1);

        m_iter.Next();

        if (m_iter.End()) {
            str += "\n";
        } else {
            str += ",\n";
        }
    }

    return str + Indent(indent) + "]";
}

 void WriteSeq(IRSeq* seq, unsigned int indent, bool noBraces)
 {
     const IRStringConst* funcName = seq->GetFuncName();
     if (funcName && !noBraces) {
         Indent(indent) << "{";
         if (funcName)
             mOut << " // " << funcName->Get();
         mOut << "\n";
         indent += 4;
     }
     const IRStmts& stmts = seq->GetStmts();
     IRStmts::const_iterator it;
     for (it = stmts.begin(); it != stmts.end(); ++it)
         Write(*it, indent);
     if (funcName && !noBraces) {
         indent -= 4;
         Indent(indent) << "}";
         if (funcName)
             mOut << " // " << funcName->Get();
         mOut << "\n";
     }
 }

HRESULT PrintingContentHandler::endElement( 
    /* [in] */ const wchar_t *pwchNamespaceUri,
    /* [in] */ int cchNamespaceUri,
    /* [in] */ const wchar_t *pwchLocalName,
    /* [in] */ int cchLocalName,
    /* [in] */ const wchar_t *pwchQName,
    /* [in] */ int cchQName)
{
    mIndent -= 4;
    Indent();
    printf( "end element \"%.*ls\"\n", cchLocalName, pwchLocalName );
    return S_OK;
}

      /// <summary>Called for each occurrence of parameterless macros</summary>
      /// <param name="match">The match.</param>
      /// <param name="depth">Debugging output depth</param>
      /// <returns>Replacement text</returns>
      wstring  DescriptionParser::onMatchKeyword(const wsmatch& match, int depth) const 
      {
         const DescriptionMacro* m;
         wstring name = (match[1].matched ? match[1].str() : match[2].str()); // Retrieve keyword/macro
         
         // Lookup macro + recursively parse
         if (DescriptionLib.Macros.TryFind(name, m))
         {
#ifdef PRINT_CONSOLE
            Console << Cons::Cyan << Indent(depth) << "Matched Keyword: " << Cons::Yellow << match[0].str()
                    << Cons::White << " with " << Cons::Yellow << m->Text << ENDL;
#endif

            return m->Recursive ? Parse(m->Text, depth+1) : m->Text;
         }

#ifdef PRINT_CONSOLE
         Console << Cons::Red << Indent(depth) << "Ignored Keyword: " << Cons::White << match[0].str() << ENDL;
#endif

         // Failed: Return match
         return match[0].str();
      }