6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-09 16:45:03 +00:00
Code Issues Projects Releases Wiki Activity

Make some more changes suggested by Chris. Manipulators go away.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@75472 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Greene 2009-07-13 16:49:27 +00:00
parent b134bc31be
commit 191cf2851b
3 changed files with 52 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
include/llvm/CodeGen/AsmFormatter.h
View File

@ -1,65 +0,0 @@
//===-- llvm/CodeGen/AsmFormatter.h - Formatted asm framework ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains various I/O manipulators to pretty-print asm.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/FormattedStream.h"
#include "llvm/Target/TargetAsmInfo.h"
namespace llvm
{
/// AsmComment - An I/O manipulator to output an end-of-line comment
///
class AsmComment : public Column {
private:
/// CommentColumn - The column at which to output a comment
///
static const int CommentColumn = 60;
/// Text - The comment to output
///
std::string Text;
/// TAI - Target information from the code generator
///
const TargetAsmInfo &TAI;
public:
AsmComment(const TargetAsmInfo &T)
: Column(CommentColumn), Text(""), TAI(T) {}
AsmComment(const std::string &Cmnt,
const TargetAsmInfo &T)
: Column(CommentColumn), Text(Cmnt), TAI(T) {}
/// operator() - Store a comments tring for later processing.
///
AsmComment &operator()(const std::string &Cmnt) {
Text = Cmnt;
return *this;
}
/// operator() - Make Comment a functor invoktable by a stream
/// output operator. This intentially hides Column's operator().
///
formatted_raw_ostream &operator()(formatted_raw_ostream &Out) const {
Column::operator()(Out);
Out << TAI.getCommentString() << " " << Text;
return(Out);
}
};
/// operator<< - Support comment formatting in formatted streams.
///
inline formatted_raw_ostream &operator<<(formatted_raw_ostream &Out,
const AsmComment &Func)
{
return(Func(Out));
}
}

49
include/llvm/Support/FormattedStream.h
View File

@ -12,23 +12,24 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_ASMSTREAM_H
#define LLVM_CODEGEN_ASMSTREAM_H
#ifndef LLVM_SUPPORT_FORMATTEDSTREAM_H
#define LLVM_SUPPORT_FORMATTEDSTREAM_H
#include "llvm/Support/raw_ostream.h"
namespace llvm
{
/// raw_asm_fd_ostream - Formatted raw_fd_ostream to handle
/// asm-specific constructs
/// formatted_raw_ostream - Formatted raw_fd_ostream to handle
/// asm-specific constructs.
///
class formatted_raw_ostream : public raw_ostream {
private:
/// TheStream - The real stream we output to
/// TheStream - The real stream we output to.
///
raw_ostream &TheStream;
/// Column - The current output column of the stream
/// Column - The current output column of the stream. The column
/// scheme is zero-based.
///
unsigned Column;
@ -63,44 +64,14 @@ namespace llvm
formatted_raw_ostream(raw_ostream &Stream)
: raw_ostream(), TheStream(Stream), Column(0) {}
/// PadToColumn - Align the output to some column number
/// PadToColumn - Align the output to some column number.
///
/// \param NewCol - The column to move to
/// \param NewCol - The column to move to.
/// \param MinPad - The minimum space to give after the most
/// recent I/O, even if the current column + minpad > newcol
/// recent I/O, even if the current column + minpad > newcol.
///
void PadToColumn(unsigned NewCol, unsigned MinPad = 0);
};
/// Column - An I/O manipulator to advance the output to a certain column
///
class Column {
private:
/// Col - The column to move to
///
unsigned int Col;
public:
explicit Column(unsigned int c)
: Col(c) {}
/// operator() - Make Column a functor invokable by a stream
/// output operator.
///
formatted_raw_ostream &operator()(formatted_raw_ostream &Out) const {
// Make at least one space before the next output
Out.PadToColumn(Col, 1);
return(Out);
}
};
/// operator<< - Support coulmn-setting in formatted streams.
///
inline formatted_raw_ostream &operator<<(formatted_raw_ostream &Out,
const Column &Func)
{
return(Func(Out));
}
}
#endif

101
lib/Support/FormattedStream.cpp
View File

@ -1,74 +1,57 @@
//===-- llvm/CodeGen/AsmStream.cpp - AsmStream Framework --------*- C++ -*-===//
//===-- llvm/Support/FormattedStream.cpp - Formatted streams ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains instantiations of "standard" AsmOStreams.
// This file contains the implementation of formatted_raw_ostream and
// friends.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/FormattedStream.h"
namespace llvm {
/// ComputeColumn - Examine the current output and figure out which
/// column we end up in after output.
///
void formatted_raw_ostream::ComputeColumn(const char *Ptr, unsigned Size)
{
// Keep track of the current column by scanning the string for
// special characters
using namespace llvm;
// Find the last newline. This is our column start. If there
// is no newline, start with the current column.
const char *nlpos = NULL;
for (const char *pos = Ptr + Size, *epos = Ptr; pos > epos; --pos) {
if (*(pos-1) == '\n') {
nlpos = pos-1;
// The newline will be counted, setting this to zero. We
// need to do it this way in case nlpos is Ptr.
Column = -1;
break;
}
}
/// ComputeColumn - Examine the current output and figure out which
/// column we end up in after output.
///
void formatted_raw_ostream::ComputeColumn(const char *Ptr, unsigned Size)
{
// Keep track of the current column by scanning the string for
// special characters
if (nlpos == NULL) {
nlpos = Ptr;
}
// Walk through looking for tabs and advance column as appropriate
for (const char *pos = nlpos, *epos = Ptr + Size; pos != epos; ++pos) {
++Column;
if (*pos == '\t') {
// Advance to next tab stop (every eight characters)
Column += ((8 - (Column & 0x7)) & 0x7);
assert(!(Column & 0x3) && "Column out of alignment");
}
}
}
/// PadToColumn - Align the output to some column number
///
/// \param NewCol - The column to move to
/// \param MinPad - The minimum space to give after the most recent
/// I/O, even if the current column + minpad > newcol
///
void formatted_raw_ostream::PadToColumn(unsigned NewCol, unsigned MinPad)
{
flush();
// Output spaces until we reach the desired column
unsigned num = NewCol - Column;
if (NewCol < Column || num < MinPad) {
num = MinPad;
}
// TODO: Write a whole string at a time
while (num-- > 0) {
write(' ');
}
for (const char *epos = Ptr + Size; Ptr != epos; ++Ptr) {
++Column;
if (*Ptr == '\n' || *Ptr == '\r')
Column = 0;
else if (*Ptr == '\t')
Column += (8 - (Column & 0x7)) & 0x7;
}
}
/// PadToColumn - Align the output to some column number.
///
/// \param NewCol - The column to move to.
/// \param MinPad - The minimum space to give after the most recent
/// I/O, even if the current column + minpad > newcol.
///
void formatted_raw_ostream::PadToColumn(unsigned NewCol, unsigned MinPad)
{
flush();
// Output spaces until we reach the desired column.
unsigned num = NewCol - Column;
if (NewCol < Column || num < MinPad) {
num = MinPad;
}
// TODO: Write a whole string at a time.
while (num-- > 0) {
write(' ');
}
}