int tool::source::Column::Check()
{
if (m_read.Open())
{
int character = 0;
std::size_t column = 1;
std::string string_line = "";
while (!m_read.IsEOF())
{
character = m_read.GetCharacter();
if (IsNewLine(character))
{
Newline(column, string_line);
column = 1;
string_line.clear();
}
else if (IsSkip(character))
{
continue;
}
else if (std::isspace(character))
{
if (character == ' ')
{
++column;
string_line.push_back(character);
}
else if (character == '\t')
{
column += (4 - ((column - 1) % 4));
string_line.push_back(character);
}
}
else
{
++column;
if (string_line.size() <
MAXIMUM_STRING_COLUMN_BUFFER_SIZE + 1)
{
string_line.push_back(character);
}
else if (string_line.size() ==
MAXIMUM_STRING_COLUMN_BUFFER_SIZE + 1)
{
string_line += "...";
}
}
}
if (!string_line.empty())
{
Newline(column - 1, string_line);
}
return 0;
}
return 1;
}
static int Putchar(char c){
switch(c){
case '\n': Newline(); return;
case '\t': NextTabStop(); return;
}
CHAR(row,column) = c;
COLOR(row,column) = 0x07;
if(column++ > WIDTH){
Newline();
}
}
static void print_probs(FILE *f, vp9_coeff_accum *context_counters,
int block_types, const char *header) {
int type, ref, band, pt, t;
fprintf(f, "static const vp9_coeff_probs %s = {", header);
type = 0;
#define Newline(x, spaces) (x ? " " : "\n" spaces)
do {
fprintf(f, "%s%s{ /* block Type %d */",
Comma(type), Newline(type, " "), type);
ref = 0;
do {
fprintf(f, "%s%s{ /* %s */",
Comma(band), Newline(band, " "), ref ? "Inter" : "Intra");
band = 0;
do {
fprintf(f, "%s%s{ /* Coeff Band %d */",
Comma(band), Newline(band, " "), band);
pt = 0;
do {
unsigned int branch_ct[ENTROPY_NODES][2];
unsigned int coef_counts[MAX_ENTROPY_TOKENS + 1];
vp9_prob coef_probs[ENTROPY_NODES];
if (pt >= 3 && band == 0)
break;
for (t = 0; t < MAX_ENTROPY_TOKENS + 1; ++t)
coef_counts[t] = context_counters[type][ref][band][pt][t];
vp9_tree_probs_from_distribution(vp9_coef_tree, coef_probs,
branch_ct, coef_counts, 0);
branch_ct[0][1] = coef_counts[MAX_ENTROPY_TOKENS] - branch_ct[0][0];
coef_probs[0] = get_binary_prob(branch_ct[0][0], branch_ct[0][1]);
fprintf(f, "%s\n {", Comma(pt));
t = 0;
do {
fprintf(f, "%s %3d", Comma(t), coef_probs[t]);
} while (++t < ENTROPY_NODES);
fprintf(f, " }");
} while (++pt < PREV_COEF_CONTEXTS);
fprintf(f, "\n }");
} while (++band < COEF_BANDS);
fprintf(f, "\n }");
} while (++ref < REF_TYPES);
fprintf(f, "\n }");
} while (++type < block_types);
fprintf(f, "\n};\n");
}
void KTextPipe::Format(const TCHAR * pattern, const void * vdata, const DicItem * dic)
{
if ( pattern == NULL )
return;
while ( * pattern )
{
switch ( * pattern )
{
case '\n':
Newline();
break;
case '#' :
pattern ++;
vdata = Pound( * pattern, (const long *) vdata, dic);
break;
case '%' :
pattern ++;
vdata = Percent( * pattern, (const long *) vdata, dic);
break;
default :
Put(* pattern);
}
pattern ++;
}
}
/*
* Put one character to the screen using the current cursor position
* and attribute, scrolling if needed. The caller should update
* the cursor position once all characters have been written.
*/
static void Output_Literal_Character(int c) {
int numSpaces;
switch (c) {
case '\n':
Clear_To_EOL();
Newline();
break;
case '\t':
numSpaces = TABWIDTH - (s_cons.col % TABWIDTH);
while (numSpaces-- > 0)
Put_Graphic_Char(' ');
break;
default:
Put_Graphic_Char(c);
break;
}
#ifndef NDEBUG
/*
* When compiled with --enable-port-e9-hack, Bochs will send writes
* to port E9 to the console. This helps tremendously with debugging,
* because it allows debug Print() statements to be visible after
* Bochs has exited.
*/
Out_Byte(0xE9, c);
#endif
}
void Serialize( FILE* fp, const B& b )
{
Write( fp, b.a );
Write( fp, b.b );
Write( fp, b.c );
Newline( fp );
}
void IRCTextCtrl::preAddMessage()
{
SetInsertionPointEnd();
if(GetLastPosition() > 0)
Newline();
}
WORD RefreshRegisters(WORD maxLines, BOOL fullRefresh) {
WORD count = 0;
if(CurDisplay->ds_RegFlag) {
RefreshRegister("D0", programD0, lastD0);
RefreshRegister("D1", programD1, lastD1);
RefreshRegister("D2", programD2, lastD2);
RefreshRegister("D3", programD3, lastD3);
count++;
Newline();
maxLines--;
if (!maxLines) return count;
RefreshRegister("D4", programD4, lastD4);
RefreshRegister("D5", programD5, lastD5);
RefreshRegister("D6", programD6, lastD6);
RefreshRegister("D7", programD7, lastD7);
count++; Newline(); maxLines--; if (!maxLines) return count;
RefreshRegister("A0", programA0, lastA0);
RefreshRegister("A1", programA1, lastA1);
RefreshRegister("A2", programA2, lastA2);
RefreshRegister("A3", programA3, lastA3);
count++; Newline(); maxLines--; if (!maxLines) return count;
RefreshRegister("A4", programA4, lastA4);
RefreshRegister("A5", programA5, lastA5);
RefreshRegister("A6", programA6, lastA6);
RefreshRegister("A7", programA7, lastA7);
count++; Newline(); maxLines--; if (!maxLines) return count;
RefreshRegister("PC", programPC, lastPC);
ScrPlain();
ScrPrintf("SR: ");
if (programSR != lastSR)ScrHighlight();
ScrPrintf("$%04X ", programSR);
DisplayFlags();
ScrPlain();
ScrPrintf("STATE: ");
if (programState != lastState)
ScrHighlight();
ScrPrintf("%s", StateText(programState));
count++; Newline(); maxLines--; if (!maxLines) return count;
}
return count;
}
BOOL ShowWatchTitle(BOOL fullRefresh, WORD *count, WORD *maxLines)
{
if(fullRefresh != -1) {
if(CurDisplay->ds_RegFlag) {
Newline();
(*count)++;
(*maxLines)++;
}
}
ScrPlain();
ScrInverse();
ScrPuts("WATCHPOINT ADDRESS CONTENTS");
// xxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxx xx
Newline();
(*count)++;
(*maxLines)++;
return TRUE;
}
/*
* Write the graphic representation of given character to the screen
* at current position, with current attribute, scrolling if
* necessary.
*/
static void Put_Graphic_Char(int c) {
uchar_t *v = VIDMEM + s_cons.row * (NUMCOLS * 2) + s_cons.col * 2;
/* Put character at current position */
*v++ = (uchar_t) c;
*v = s_cons.currentAttr;
if(s_cons.col < NUMCOLS - 1)
++s_cons.col;
else
Newline();
}
//! ************************************************************************************************
//!
//! ************************************************************************************************
void rdmp::SignalsHelloWorld()
{
boost::signals2::signal<void()> sigHellWorld;
sigHellWorld.connect(HellWorld());
sigHellWorld();
boost::signals2::signal<void()> sigWooHoo;
sigWooHoo.connect(Woo());
sigWooHoo.connect(Hoo());
sigWooHoo.connect(Newline());
sigWooHoo();
// slots are invoked this order:
// 1) ungrouped slots connected with boost::signals2::at_front
// 2) grouped slots according to ordering of their groups
// 3) ungrouped slots connected with boost::signals2::at_back
boost::signals2::signal<void()> sigHooWoo;
sigHooWoo.connect(1, Woo());
sigHooWoo.connect(0, Hoo());
sigHooWoo.connect(2, Newline());
sigHooWoo();
}
void TextTerminal::PutChar(TextBuffer* textbuf, char c)
{
if ( ansimode )
return PutAnsiEscaped(textbuf, c);
if ( mbsinit(&ps) )
{
switch ( c )
{
case '\n': Newline(textbuf); return;
case '\r': column = 0; return;
case '\b': Backspace(textbuf); return;
case '\t': Tab(textbuf); return;
case '\e': AnsiReset(); return;
case 127: return;
default: break;
}
}
wchar_t wc;
size_t result = mbrtowc(&wc, &c, 1, &ps);
if ( result == (size_t) -2 )
return;
if ( result == (size_t) -1 )
{
memset(&ps, 0, sizeof(ps));
wc = L'�';
}
if ( result == (size_t) 0 )
wc = L' ';
if ( textbuf->Width() <= column )
Newline(textbuf);
TextPos pos(column++, line);
TextChar tc(wc, vgacolor, ATTR_CHAR | next_attr);
textbuf->SetChar(pos, tc);
next_attr = 0;
}
void TextTerminal::Tab(TextBuffer* textbuf)
{
if ( column == textbuf->Width() )
Newline(textbuf);
unsigned int count = 8 - (column % 8);
for ( unsigned int i = 0; i < count; i++ )
{
if ( column == textbuf->Width() )
break;
TextPos pos(column++, line);
TextChar tc(' ', vgacolor, i == 0 ? ATTR_CHAR : 0);
textbuf->SetChar(pos, tc);
}
}
// parses the next token
// returns false if done
void opScanner::ScanTokens(const inputtype& Input) {
// if we've reached the end of the Input stream,
// add an EOF token and return false
int size = Input.Size();
int current = 0;
// TODO: the input list of chars is really a bad idea
// Input should be a vector, and we should not alter it,
// instead we should iterate over it (maybe w/ an iterator we pass
// around.
while (current != size) {
// scan for the next token
// (with the correct precedence)
if (current != size && Newline(Input, current))
;
else if (current != size && CComment(Input, current))
;
else if (current != size && Comment(Input, current))
;
else if (current != size && String(Input, current))
;
else if (current != size && WhiteSpace(Input, current))
;
else if (current != size && Operator(Input, current))
;
else if (current != size && Hexadecimals(Input, current))
;
else if (current != size && Number(Input, current))
;
else if (current != size && GetId(Input, current))
;
else if (current != size) {
opToken newToken(T_ANYCHAR, Input[current], CurrentLine);
Tokens.PushBack(newToken);
++current;
}
}
Tokens.PushBack(opToken(T_EOF, "", CurrentLine));
}
void KTextPipe::WriteArray(const void * Array, long count, long elmsize, bool decimal)
{
if ( ! m_bOpened )
return;
assert(Array);
const char * bArray = (const char *) Array;
const short * sArray = (const short *) Array;
const long * lArray = (const long *) Array;
const RECT * rArray = (const RECT *) Array;
Put('{'); Put(' ');
for (long i=0; i<count; i++)
{
if ( i )
{
Put(',');
if ( m_linelen > 78 )
Newline();
else
Put(' ');
}
switch ( elmsize )
{
case 1:
if (decimal)
WriteDec((long) bArray[i]);
else
WriteHex(bArray[i] & 0xFF);
break;
case 2:
if (decimal)
WriteDec((long) sArray[i]);
else
WriteHex(sArray[i] & 0xFFFF);
break;
case 4:
if (decimal)
WriteDec(lArray[i]);
else
WriteHex(lArray[i]);
break;
case sizeof(RECT):
Write("{ "); WriteDec(rArray[i].left);
Put(','); WriteDec(rArray[i].top);
Put(','); WriteDec(rArray[i].right);
Put(','); WriteDec(rArray[i].bottom);
Write(" }");
break;
default: assert(FALSE);
}
}
Put(' '); Put('}');
}
WORD RefreshWatchpoints(WORD maxLines, BOOL fullRefresh) {
WORD count = 0;
WORD i, undef;
ULONG val;
BOOL flag = FALSE;
for (i=0; i<MAXWP && maxLines > 0; i++) {
switch (wpTable[i].type) {
case WP_UNSET:
break;
case WP_BYTES:
val = ParseExp(wpTable[i].expression, &undef, strlen(wpTable[i].expression));
if (undef)
ScrPrintf("%-24.24s *UNDEFINED*", wpTable[i].expression);
else {
WORD j = (CurDisplay->ds_ScrCols-35)/3;
UBYTE *ps = (UBYTE *)val;
if (!flag) {
flag = ShowWatchTitle(fullRefresh,&count,&maxLines);
}
ScrPrintf("%-24.24s %08X ", wpTable[i].expression, val);
while (j > 0) {
ScrPrintf("%02X ", *ps++);
--j;
}
}
count++;
Newline();
maxLines--;
break;
case WP_WORDS:
val = ParseExp(wpTable[i].expression, &undef, strlen(wpTable[i].expression));
if (undef)
ScrPrintf("%-24.24s *UNDEFINED*", wpTable[i].expression);
else {
WORD j = (CurDisplay->ds_ScrCols-35)/5;
UWORD *ps = (UWORD *)val;
if (!flag) {
flag = ShowWatchTitle(fullRefresh,&count,&maxLines);
}
ScrPrintf("%-24.24s %08X ", wpTable[i].expression, val);
while (j > 0) {
ScrPrintf("%04X ", *ps++);
--j;
}
}
count++; Newline(); maxLines--;
break;
case WP_LONGS:
val = ParseExp(wpTable[i].expression, &undef, strlen(wpTable[i].expression));
if (undef)
ScrPrintf("%-24.24s *UNDEFINED*", wpTable[i].expression);
else {
WORD j = (CurDisplay->ds_ScrCols-35)/9;
ULONG *ps = (ULONG *)val;
if (!flag) {
flag = ShowWatchTitle(fullRefresh,&count,&maxLines);
}
ScrPrintf("%-24.24s %08X ", wpTable[i].expression, val);
while (j > 0) {
ScrPrintf("%08X ", *ps++);
--j;
}
}
count++;
Newline();
maxLines--;
break;
}
}
// add a newline to end if at top of screen
if(flag && !CurDisplay->ds_RegFlag) {
Newline();
count++;
maxLines++;
}
return count;
}
static void NextTabStop(){
column += TABSTOP - (column%TABSTOP);
if(column > WIDTH)
Newline();
}
int
ParseInput(register DviWidget dw)
{
int n, k;
int c;
char Buffer[BUFSIZ];
int NextPage;
int otherc;
StopSeen = 0;
/*
* make sure some state exists
*/
if (!dw->dvi.state)
push_env (dw);
for (;;) {
switch (DviGetC(dw, &c)) {
case '\n':
break;
case ' ': /* when input is text */
case 0: /* occasional noise creeps in */
break;
case '{': /* push down current environment */
push_env(dw);
break;
case '}':
pop_env(dw);
break;
/*
* two motion digits plus a character
*/
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
HorizontalMove(dw, (c-'0')*10 +
DviGetC(dw,&otherc)-'0');
/* fall through */
case 'c': /* single ascii character */
DviGetC(dw,&c);
if (c == ' ')
break;
Buffer[0] = c;
Buffer[1] = '\0';
(void) PutCharacter (dw, Buffer);
break;
case 'C':
GetWord (dw, Buffer, BUFSIZ);
(void) PutCharacter (dw, Buffer);
break;
case 't':
Buffer[1] = '\0';
while (DviGetC (dw, &c) != EOF
&& c != ' ' && c != '\n') {
Buffer[0] = c;
HorizontalMove (dw, PutCharacter (dw, Buffer));
}
break;
case 'u':
n = GetNumber(dw);
Buffer[1] = '\0';
while (DviGetC (dw, &c) == ' ')
;
while (c != EOF && c != ' ' && c != '\n') {
Buffer[0] = c;
HorizontalMove (dw,
PutCharacter (dw, Buffer) + n);
DviGetC (dw, &c);
}
break;
case 'D': /* draw function */
(void) GetLine(dw, Buffer, BUFSIZ);
if (dw->dvi.display_enable)
ParseDrawFunction(dw, Buffer);
break;
case 's': /* ignore fractional sizes */
n = GetNumber(dw);
dw->dvi.state->font_size = n;
break;
case 'f':
n = GetNumber(dw);
dw->dvi.state->font_number = n;
break;
case 'H': /* absolute horizontal motion */
k = GetNumber(dw);
HorizontalGoto(dw, k);
break;
case 'h': /* relative horizontal motion */
k = GetNumber(dw);
HorizontalMove(dw, k);
break;
case 'w': /* word space */
Word (dw);
break;
case 'V':
n = GetNumber(dw);
VerticalGoto(dw, n);
break;
case 'v':
n = GetNumber(dw);
VerticalMove(dw, n);
break;
case 'P': /* new spread */
break;
case 'p': /* new page */
(void) GetNumber(dw);
NextPage = dw->dvi.current_page + 1;
RememberPagePosition(dw, NextPage);
FlushCharCache (dw);
return(NextPage);
case 'N':
n = GetNumber(dw);
PutNumberedCharacter (dw, n);
break;
case 'n': /* end of line */
GetNumber(dw);
GetNumber(dw);
Newline (dw);
HorizontalGoto(dw, 0);
break;
case 'F': /* input files */
case '+': /* continuation of X device control */
case 'm': /* color */
case '#': /* comment */
GetLine(dw, NULL, 0);
break;
case 'x': /* device control */
ParseDeviceControl(dw);
break;
case EOF:
dw->dvi.last_page = dw->dvi.current_page;
FlushCharCache (dw);
return dw->dvi.current_page;
default:
break;
}
}
}
void Serialize( FILE* fp, const C& c )
{
Write( fp, c.a );
Serialize( fp, c.b );
Newline( fp );
}
void Serialize( FILE* fp, const A& a )
{
Write( fp, a.a );
Write( fp, a.b );
Newline( fp );
}
