void QgsLayoutItemPolyline::drawEndMarker( QPainter *painter )
{
if ( mPolygon.size() < 2 )
return;
switch ( mEndMarker )
{
case MarkerMode::NoMarker:
break;
case MarkerMode::ArrowHead:
{
// calculate angle at end of line
QLineF endLine( mPolygon.at( mPolygon.count() - 2 ), mPolygon.at( mPolygon.count() - 1 ) );
double angle = endLine.angle();
//move end point depending on arrow width
QVector2D dir = QVector2D( endLine.dx(), endLine.dy() ).normalized();
QPointF endPoint = endLine.p2();
endPoint += ( dir * 0.5 * mArrowHeadWidth ).toPointF();
drawArrow( painter, endPoint, angle );
break;
}
case MarkerMode::SvgMarker:
{
// calculate angle at end of line
QLineF endLine( mPolygon.at( mPolygon.count() - 2 ), mPolygon.at( mPolygon.count() - 1 ) );
double angle = endLine.angle();
drawSvgMarker( painter, endLine.p2(), angle, mEndMarkerFile, mEndArrowHeadHeight );
break;
}
}
}
static int
doListKeyTable (ListGenerationData *lgd) {
if (!putUtf8String(lgd, gettext("Key Table"))) return 0;
if (lgd->keyTable->title) {
if (!putCharacterString(lgd, WS_C(": "))) return 0;
if (!putCharacterString(lgd, lgd->keyTable->title)) return 0;
if (!endLine(lgd)) return 0;
}
if (lgd->keyTable->noteCount) {
unsigned int noteIndex;
if (!endLine(lgd)) return 0;
for (noteIndex=0; noteIndex<lgd->keyTable->noteCount; noteIndex+=1) {
if (!putCharacterString(lgd, lgd->keyTable->noteTable[noteIndex])) return 0;
if (!endLine(lgd)) return 0;
}
}
{
static const unsigned char contexts[] = {
KTB_CTX_DEFAULT,
KTB_CTX_MENU
};
const unsigned char *context = contexts;
unsigned int count = ARRAY_COUNT(contexts);
while (count) {
const KeyContext *ctx = getKeyContext(lgd->keyTable, *context);
if (ctx) {
lgd->sectionTitle = ctx->title;
if (!listKeyContext(lgd, ctx, NULL)) return 0;
}
context += 1, count -= 1;
}
}
{
unsigned int context;
for (context=KTB_CTX_DEFAULT+1; context<lgd->keyTable->keyContextCount; context+=1) {
const KeyContext *ctx = getKeyContext(lgd->keyTable, context);
if (ctx && !isTemporaryKeyContext(lgd->keyTable, ctx)) {
lgd->sectionTitle = ctx->title;
if (!listKeyContext(lgd, ctx, NULL)) return 0;
}
}
}
return 1;
}
static int
listKeyBinding (ListGenerationData *lgd, const KeyBinding *binding, int longPress, const wchar_t *keysPrefix) {
const BoundCommand *cmd = longPress? &binding->secondaryCommand: &binding->primaryCommand;
size_t keysOffset;
if (cmd->value == BRL_CMD_NOOP) return 1;
if (!putCommandDescription(lgd, cmd, !binding->keyCombination.anyKeyCount)) return 0;
if (!putCharacterString(lgd, WS_C(": "))) return 0;
keysOffset = lgd->line.length;
if (keysPrefix) {
if (!putCharacterString(lgd, keysPrefix)) return 0;
if (!putCharacterString(lgd, WS_C(", "))) return 0;
}
if (longPress) {
if (!putCharacterString(lgd, WS_C("long "))) return 0;
}
if (!putKeyCombination(lgd, &binding->keyCombination)) return 0;
if ((cmd->value & BRL_MSK_BLK) == BRL_BLK_CONTEXT) {
const KeyContext *c = getKeyContext(lgd->keyTable, (KTB_CTX_DEFAULT + (cmd->value & BRL_MSK_ARG)));
if (!c) return 0;
{
size_t length = lgd->line.length - keysOffset;
wchar_t keys[length + 1];
wmemcpy(keys, &lgd->line.characters[keysOffset], length);
keys[length] = 0;
lgd->line.length = 0;
if (isTemporaryKeyContext(lgd->keyTable, c)) {
if (!listKeyContext(lgd, c, keys)) return 0;
} else {
if (!putCharacterString(lgd, WS_C("switch to "))) return 0;
if (!putCharacterString(lgd, c->title)) return 0;
if (!putCharacterString(lgd, WS_C(": "))) return 0;
if (!putCharacterString(lgd, keys)) return 0;
if (!endLine(lgd)) return 0;
}
}
} else {
if (!endLine(lgd)) return 0;
}
return 1;
}
void PrintHandler::startArray()
{
_out << '[' << endLine();
_tab.append(indent(), ' ');
_array = true;
_value = false;
}
void PrintHandler::endObject()
{
if( _tab.length() >= indent())
_tab.erase(_tab.length() - indent());
_out << endLine() << _tab << '}';
}
void PrintHandler::endArray()
{
_tab.erase(_tab.length() - indent());
_out << endLine() << _tab << ']';
_array = false;
_value = false;
}
void PrintHandler::startObject()
{
arrayValue();
_out << '{';
_out << endLine();
_tab.append(indent(), ' ');
_objStart = true;
}
void PrintHandler::startArray()
{
arrayValue();
_out << '[' << endLine();
_tab.append(indent(), ' ');
++_array;
_objStart = true;
}
static void
PrintGasConstantDecl(FILE *f, AST *ast, int inlineAsm)
{
startLine(f, inlineAsm);
fprintf(f, "\t\t.equ\t%s, ", ast->d.string);
PrintInteger(f, EvalConstExpr(ast));
endLine(f, inlineAsm);
}
void PrintHandler::endArray()
{
_tab.erase(_tab.length() - indent());
_out << endLine() << _tab << ']';
--_array;
poco_assert (_array >= 0);
_objStart = false;
}
/* public */
Geometry*
LinearGeometryBuilder::getGeometry()
{
// end last line in case it was not done by user
endLine();
// NOTE: lines elements are cloned
return geomFact->buildGeometry(lines);
}
void CSVOutputStream::writeHeaderLn(size32_t len, const char * data)
{
append(len,data);
if (!oldOutputFormat&&len) {
size32_t tl = terminator.length();
if ((tl>len)||(memcmp(data+len-tl,terminator.get(),tl)!=0))
endLine();
}
}
/**
void Port::sendAll (void)
Sends sensor data from each active port.
@param void
@return void
**/
void Port::sendAll (void){
for (uint8_t portAddress = 1; portAddress <= PORT_MAX; portAddress++){
if((*ports[portAddress-1]).isActive()){
sendPortData (portAddress);
if (portAddress != lastPort){
endLine();
}
}
}
}
static int
listKeyboardFunctions (ListGenerationData *lgd, const KeyContext *ctx) {
const char *prefix = "braille keyboard ";
{
unsigned int index;
for (index=0; index<ctx->mappedKeyCount; index+=1) {
const MappedKeyEntry *map = &ctx->mappedKeyTable[index];
const KeyboardFunction *kbf = map->keyboardFunction;
if (!putUtf8String(lgd, prefix)) return 0;
if (!putUtf8String(lgd, kbf->name)) return 0;
if (!putCharacterString(lgd, WS_C(": "))) return 0;
if (!putKeyName(lgd, &map->keyValue)) return 0;
if (!endLine(lgd)) return 0;
}
}
{
const KeyboardFunction *kbf = keyboardFunctionTable;
const KeyboardFunction *end = kbf + keyboardFunctionCount;
while (kbf < end) {
if (ctx->superimposedBits & kbf->bit) {
if (!putUtf8String(lgd, prefix)) return 0;
if (!putUtf8String(lgd, kbf->name)) return 0;
if (!putCharacterString(lgd, WS_C(": superimposed"))) return 0;
if (!endLine(lgd)) return 0;
}
kbf += 1;
}
}
return 1;
}
Graphics::Surface *TinyGLRenderer::getScreenshot() {
Graphics::Surface *s = new Graphics::Surface();
s->create(kOriginalWidth, kOriginalHeight, Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24));
Graphics::PixelBuffer buf(s->format, (byte *)s->getPixels());
_fb->copyToBuffer(buf);
//Vertical flip in place:
Graphics::PixelBuffer startLine(s->format, kOriginalWidth, DisposeAfterUse::YES);
Graphics::PixelBuffer endLine(s->format, kOriginalWidth, DisposeAfterUse::YES);
for(int y = 0; y < kOriginalHeight / 2; y++)
{
startLine.copyBuffer(0, y * kOriginalWidth, kOriginalWidth, buf);
endLine.copyBuffer(0, (kOriginalHeight - y - 1) * kOriginalWidth, kOriginalWidth, buf);
buf.copyBuffer(y * kOriginalWidth, 0, kOriginalWidth, endLine);
buf.copyBuffer((kOriginalHeight - y - 1) * kOriginalWidth, 0, kOriginalWidth, startLine);
}
return s;
}
int main()
{
Widget w;
{
std::cout << "Create auto from Widget:\n";
std::cout << " Direct init w/parens: "; auto wcopy1(w); endLine(); // now using auto
std::cout << " Copy init : "; auto wcopy2 = w; endLine();
std::cout << " Direct init w/braces: "; auto wcopy3 {w}; endLine();
endLine();
}
const Widget cw;
{
std::cout << "Create auto from const Widget:\n";
std::cout << " Direct init w/parens: "; auto wcopy1(cw); endLine();
std::cout << " Copy init : "; auto wcopy2 = cw; endLine();
std::cout << " Direct init w/braces: "; auto wcopy3 {cw}; endLine();
endLine();
}
}
static int
listHotkeyEvent (ListGenerationData *lgd, const KeyValue *keyValue, const char *event, int command) {
if (command != BRL_CMD_NOOP) {
if ((command & BRL_MSK_BLK) == BRL_BLK_CONTEXT) {
const KeyContext *c = getKeyContext(lgd->keyTable, (KTB_CTX_DEFAULT + (command & BRL_MSK_ARG)));
if (!c) return 0;
if (!putUtf8String(lgd, "switch to ")) return 0;
if (!putCharacterString(lgd, c->title)) return 0;
} else {
if (!putCommandDescription(lgd, command, (keyValue->key != KTB_KEY_ANY))) return 0;
}
if (!putCharacterString(lgd, WS_C(": "))) return 0;
if (!putUtf8String(lgd, event)) return 0;
if (!putCharacter(lgd, WC_C(' '))) return 0;
if (!putKeyName(lgd, keyValue)) return 0;
if (!endLine(lgd)) return 0;
}
return 1;
}
/**
void Port::sendSavedData (uint16_t amount)
Reads sensor data from EEPROM and sends to SCIO app
@param uint8_t amount
The number of previous measurments to be sent to the scio application. If there are no
measurments stored on the EEPROM and ABORT response is sent. If the requested amount is greater
than the number of measurments stored on the EEPROM all data is sent.
@return void
**/
void Port::sendSavedData (uint16_t amount){
//create information block to store data once it is read from memory
ExperimentBlock experiment;
DataBlock dataBlock;
//load experiement parameters from memory.
(*memory).loadExperimentBlock(&experiment);
//get memory pointers
uint16_t ptr = (*memory).getPtr(amount*activePorts);
uint16_t tail = (*memory).tail();
//check if there is no sensor information
if (ptr == (*memory).tail()){
respond(SDI_ABORT);
}
//itterate through in time forwards order
for (ptr ; ptr != tail; (*memory).updatePtr(&ptr)){
//load current data block
(*memory).loadDataBlock(ptr, &dataBlock);
//recover time measurment was taken.
uint32_t Time = experiment.startTime + dataBlock.periodNumber* experiment.periodLgth;
//recover port address
uint8_t port = dataBlock.port;
//recovering stored data type
if ((*ports[port-1]).getType() == SENSOR_TYPE_A){
SENSOR_RETURN_TYPE_A data = *(reinterpret_cast <SENSOR_RETURN_TYPE_A*> (&dataBlock.data));
//send data report with correclty formateed sensor data
dataReport(port, Time, data);
}
else if ((*ports[port-1]).getType() == SENSOR_TYPE_B){
SENSOR_RETURN_TYPE_B data = *(reinterpret_cast <SENSOR_RETURN_TYPE_B*> (&dataBlock.data));
//semd data report with correctly formated sensor data
dataReport(port, Time, data);
}
//send terminator
if (ptr == tail-1){
terminate();
}
//send endline
endLine();
}
}
/** appends extension to line and prints it to the give file stream if the line exceeded
PPM_PRINTLEN */
static
void appendLine(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< output file (or NULL for standard output) */
SCIP_READERDATA* readerdata, /**< information for reader */
char* linebuffer, /**< line */
int* linecnt, /**< number of characters in line */
const char* extension /**< string to extent the line */
)
{
assert( scip != NULL );
assert( linebuffer != NULL );
assert( linecnt != NULL );
assert( extension != NULL );
if( *linecnt + strlen(extension) > PPM_MAX_LINELEN - 1 )
endLine(scip, file, readerdata, linebuffer, linecnt);
/* append extension to linebuffer */
strncat(linebuffer, extension, PPM_MAX_LINELEN - (unsigned int)(*linecnt) - 1);
(*linecnt) += (int) strlen(extension);
}
bool disassembleExport(DisassembleState &state, latte::cf::inst id, latte::cf::Instruction &cf)
{
auto eid = static_cast<latte::exp::inst>(cf.expWord1.inst);
auto name = latte::exp::name[id];
auto type = static_cast<latte::exp::Type::Type>(cf.expWord0.type);
state.out
<< name
<< ": ";
switch (type) {
case latte::exp::Type::Pixel:
state.out << "PIX";
break;
case latte::exp::Type::Position:
state.out << "POS";
break;
case latte::exp::Type::Parameter:
state.out << "PARAM";
break;
}
state.out
<< cf.expWord0.dstReg;
state.out
<< ", R"
<< cf.expWord0.srcReg
<< ".";
writeSelectName(state, cf.expWord1.srcSelX);
writeSelectName(state, cf.expWord1.srcSelY);
writeSelectName(state, cf.expWord1.srcSelZ);
writeSelectName(state, cf.expWord1.srcSelW);
endLine(state);
return true;
}
QString toListViewFormatterHTML::getFormattedString(toExportSettings &settings,
//const toResultModel *model);
const QAbstractItemModel * model)
{
int columns = model->columnCount();
int rows = model->rowCount();
QString output;
QString indent;
QVector<int> rlist = selectedRows(settings.selected);
QVector<int> clist = selectedColumns(settings.selected);
output = QString("<HTML><HEAD><TITLE>Export</TITLE></HEAD><BODY><TABLE>");
endLine(output);
QString bgcolor;
if (settings.columnsHeader)
{
output += QString("<TR>");
endLine(output);
for (int j = 0; j < columns; j++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(j))
continue;
output += QString("\t<TH>");
endLine(output);
QString text(Qt::escape(model->headerData(j,
Qt::Horizontal,
Qt::DisplayRole).toString()));
output += "\t\t" + text;
endLine(output);
output += QString("\t</TH>");
endLine(output);
}
output += "</TR>";
endLine(output);
}
QModelIndex mi;
for (int row = 0; row < rows; row++)
{
if (settings.rowsExport == toExportSettings::RowsSelected && !rlist.contains(row))
continue;
output += "<TR>";
endLine(output);
for (int i = 0; i < columns; i++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(i))
continue;
if (!settings.rowsHeader && i == 0)
continue;
output += QString("\t<TD>");
endLine(output);
mi = model->index(row, i);
QString text(Qt::escape(model->data(mi, Qt::EditRole).toString()));
output += "\t\t" + text;
endLine(output);
output += QString("\t</TD>");
endLine(output);
}
output += "</TR>";
endLine(output);
}
output += "</TABLE></BODY></HTML>";
return output;
}
static int
listKeyContext (ListGenerationData *lgd, const KeyContext *ctx, const wchar_t *keysPrefix) {
{
const HotkeyEntry *hotkey = ctx->hotkeyTable;
unsigned int count = ctx->hotkeyCount;
while (count) {
if (!(hotkey->flags & HKF_HIDDEN)) {
if (!listHotkeyEvent(lgd, &hotkey->keyValue, "press", hotkey->pressCommand)) return 0;
if (!listHotkeyEvent(lgd, &hotkey->keyValue, "release", hotkey->releaseCommand)) return 0;
}
hotkey += 1, count -= 1;
}
}
{
const KeyBinding *binding = ctx->keyBindingTable;
unsigned int count = ctx->keyBindingCount;
while (count) {
if (!(binding->flags & KBF_HIDDEN)) {
size_t keysOffset;
if (!putCommandDescription(lgd, binding->command, !binding->combination.anyKeyCount)) return 0;
if (!putCharacterString(lgd, WS_C(": "))) return 0;
keysOffset = lgd->lineLength;
if (keysPrefix) {
if (!putCharacterString(lgd, keysPrefix)) return 0;
if (!putCharacterString(lgd, WS_C(", "))) return 0;
}
if (!putKeyCombination(lgd, &binding->combination)) return 0;
if ((binding->command & BRL_MSK_BLK) == BRL_BLK_CONTEXT) {
const KeyContext *c = getKeyContext(lgd->keyTable, (KTB_CTX_DEFAULT + (binding->command & BRL_MSK_ARG)));
if (!c) return 0;
{
size_t length = lgd->lineLength - keysOffset;
wchar_t keys[length + 1];
wmemcpy(keys, &lgd->lineCharacters[keysOffset], length);
keys[length] = 0;
lgd->lineLength = 0;
if (isTemporaryKeyContext(lgd->keyTable, c)) {
if (!listKeyContext(lgd, c, keys)) return 0;
} else {
if (!putCharacterString(lgd, WS_C("switch to "))) return 0;
if (!putCharacterString(lgd, c->title)) return 0;
if (!putCharacterString(lgd, WS_C(": "))) return 0;
if (!putCharacterString(lgd, keys)) return 0;
if (!endLine(lgd)) return 0;
}
}
} else {
if (!endLine(lgd)) return 0;
}
}
binding += 1, count -= 1;
}
}
if (!listKeyboardFunctions(lgd, ctx)) return 0;
return 1;
}
void PrintHandler::startObject()
{
_out << '{';
_out << endLine();
_tab.append(indent(), ' ');
}
bool DRAWING_TOOL::drawArc( DRAWSEGMENT*& aGraphic )
{
bool clockwise = true; // drawing direction of the arc
double startAngle = 0.0f; // angle of the first arc line
VECTOR2I cursorPos = m_controls->GetCursorPosition();
DRAWSEGMENT helperLine;
helperLine.SetShape( S_SEGMENT );
helperLine.SetLayer( Dwgs_User );
helperLine.SetWidth( 1 );
// Add a VIEW_GROUP that serves as a preview for the new item
KIGFX::VIEW_GROUP preview( m_view );
m_view->Add( &preview );
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
m_controls->ShowCursor( true );
m_controls->SetSnapping( true );
Activate();
enum ARC_STEPS
{
SET_ORIGIN = 0,
SET_END,
SET_ANGLE,
FINISHED
};
int step = SET_ORIGIN;
// Main loop: keep receiving events
while( OPT_TOOL_EVENT evt = Wait() )
{
cursorPos = m_controls->GetCursorPosition();
if( evt->IsCancel() || evt->IsActivate() )
{
preview.Clear();
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
delete aGraphic;
aGraphic = NULL;
break;
}
else if( evt->IsClick( BUT_LEFT ) )
{
switch( step )
{
case SET_ORIGIN:
{
LAYER_ID layer = m_frame->GetScreen()->m_Active_Layer;
if( IsCopperLayer( layer ) )
{
DisplayInfoMessage( NULL, _( "Graphic not allowed on Copper layers" ) );
--step;
}
else
{
// Init the new item attributes
aGraphic->SetShape( S_ARC );
aGraphic->SetAngle( 0.0 );
aGraphic->SetWidth( getSegmentWidth( layer ) );
aGraphic->SetCenter( wxPoint( cursorPos.x, cursorPos.y ) );
aGraphic->SetLayer( layer );
helperLine.SetStart( aGraphic->GetCenter() );
helperLine.SetEnd( aGraphic->GetCenter() );
preview.Add( aGraphic );
preview.Add( &helperLine );
m_controls->SetAutoPan( true );
m_controls->CaptureCursor( true );
}
}
break;
case SET_END:
{
if( wxPoint( cursorPos.x, cursorPos.y ) != aGraphic->GetCenter() )
{
VECTOR2D startLine( aGraphic->GetArcStart() - aGraphic->GetCenter() );
startAngle = startLine.Angle();
aGraphic->SetArcStart( wxPoint( cursorPos.x, cursorPos.y ) );
}
else
--step; // one another chance to draw a proper arc
}
break;
case SET_ANGLE:
{
if( wxPoint( cursorPos.x, cursorPos.y ) != aGraphic->GetArcStart() && aGraphic->GetAngle() != 0 )
{
assert( aGraphic->GetArcStart() != aGraphic->GetArcEnd() );
assert( aGraphic->GetWidth() > 0 );
m_view->Add( aGraphic );
aGraphic->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
preview.Remove( aGraphic );
preview.Remove( &helperLine );
}
else
--step; // one another chance to draw a proper arc
}
break;
}
if( ++step == FINISHED )
break;
}
else if( evt->IsMotion() )
{
switch( step )
{
case SET_END:
helperLine.SetEnd( wxPoint( cursorPos.x, cursorPos.y ) );
aGraphic->SetArcStart( wxPoint( cursorPos.x, cursorPos.y ) );
break;
case SET_ANGLE:
{
VECTOR2D endLine( wxPoint( cursorPos.x, cursorPos.y ) - aGraphic->GetCenter() );
double newAngle = RAD2DECIDEG( endLine.Angle() - startAngle );
// Adjust the new angle to (counter)clockwise setting
if( clockwise && newAngle < 0.0 )
newAngle += 3600.0;
else if( !clockwise && newAngle > 0.0 )
newAngle -= 3600.0;
aGraphic->SetAngle( newAngle );
}
break;
}
// Show a preview of the item
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::incWidth ) )
{
aGraphic->SetWidth( aGraphic->GetWidth() + WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::decWidth ) )
{
int width = aGraphic->GetWidth();
if( width > WIDTH_STEP )
{
aGraphic->SetWidth( width - WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
else if( evt->IsAction( &COMMON_ACTIONS::arcPosture ) )
{
if( clockwise )
aGraphic->SetAngle( aGraphic->GetAngle() - 3600.0 );
else
aGraphic->SetAngle( aGraphic->GetAngle() + 3600.0 );
clockwise = !clockwise;
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
m_controls->ShowCursor( false );
m_controls->SetSnapping( false );
m_controls->SetAutoPan( false );
m_controls->CaptureCursor( false );
m_view->Remove( &preview );
return ( step > SET_ORIGIN );
}
bool disassembleTEX(DisassembleState &state, latte::cf::inst cfID, latte::cf::Instruction &cf)
{
const uint32_t *ptr = state.words + (latte::WordsPerCF * cf.word0.addr);
state.out
<< latte::cf::name[cfID] << ": "
<< "ADDR(" << cf.word0.addr << ") CNT(" << (cf.word1.count + 1) << ")";
endLine(state);
increaseIndent(state);
for (auto slot = 0u; slot <= cf.word1.count; ) {
auto tex = *reinterpret_cast<const latte::tex::Instruction*>(ptr);
auto name = latte::tex::name[tex.word0.inst];
auto id = tex.word0.inst;
if (id == latte::tex::VTX_FETCH || id == latte::tex::VTX_SEMANTIC || id == latte::tex::GET_BUFFER_RESINFO) {
assert(false);
ptr += latte::WordsPerVTX;
} else if (id == latte::tex::MEM) {
assert(false);
ptr += latte::WordsPerMEM;
} else {
beginLine(state);
state.out
<< fmt::pad(state.group, groupCounterSize, '0')
<< ' '
<< name
<< ' ';
// Write dst
if (tex.word1.dstRel != 0) {
// TODO: relative address
state.out << "__UNK_REL(" << tex.word1.dstRel << ")__";
}
writeRegisterName(state, tex.word1.dstReg);
state.out << '.';
writeSelectName(state, tex.word1.dstSelX);
writeSelectName(state, tex.word1.dstSelY);
writeSelectName(state, tex.word1.dstSelZ);
writeSelectName(state, tex.word1.dstSelW);
// Write src
state.out << ", ";
if (tex.word0.srcRel != 0) {
// TODO: relative address
state.out << "__UNK_REL(" << tex.word0.srcRel << ")__";
}
writeRegisterName(state, tex.word0.srcReg);
state.out << '.';
writeSelectName(state, tex.word2.srcSelX);
writeSelectName(state, tex.word2.srcSelY);
writeSelectName(state, tex.word2.srcSelZ);
writeSelectName(state, tex.word2.srcSelW);
state.out
<< ", t" << tex.word0.resourceID
<< ", s" << tex.word2.samplerID;
if (tex.word2.offsetX || tex.word2.offsetY || tex.word2.offsetZ) {
state.out
<< " OFFSET("
<< tex.word2.offsetX
<< ", "
<< tex.word2.offsetY
<< ", "
<< tex.word2.offsetZ
<< ")";
}
if (tex.word1.lodBias) {
state.out << " LOD_BIAS(" << tex.word1.lodBias << ")";
}
if (!tex.word1.coordTypeX) {
state.out << " CTX_UNORM";
}
if (!tex.word1.coordTypeY) {
state.out << " CTY_UNORM";
}
if (!tex.word1.coordTypeZ) {
state.out << " CTZ_UNORM";
}
if (!tex.word1.coordTypeW) {
state.out << " CTW_UNORM";
}
if (tex.word0.bcFracMode) {
state.out << " BFM";
}
if (tex.word0.fetchWholeQuad) {
state.out << " FWQ";
}
endLine(state);
ptr += latte::WordsPerTEX;
}
state.group++;
slot++;
}
decreaseIndent(state);
return true;
}
bool disassembleALU(DisassembleState &state, latte::cf::inst id, latte::cf::Instruction &cf)
{
const uint64_t *slots = reinterpret_cast<const uint64_t *>(state.words + (latte::WordsPerCF * cf.aluWord0.addr));
state.out
<< latte::alu::name[cf.aluWord1.inst] << ": "
<< "ADDR(" << cf.aluWord0.addr << ") CNT(" << (cf.aluWord1.count + 1) << ")";
increaseIndent(state);
for (auto slot = 0u; slot <= cf.aluWord1.count; ) {
static char unitName[] = { 'x', 'y', 'z', 'w', 't' };
bool units[5] = { false, false, false, false, false };
bool last = false;
const uint32_t *literalPtr = reinterpret_cast<const uint32_t*>(slots + slot);
auto literals = 0u;
endLine(state);
for (auto i = 0u; i < 5 && !last; ++i) {
auto alu = *reinterpret_cast<const latte::alu::Instruction*>(slots + slot + i);
literalPtr += 2;
last = !!alu.word0.last;
}
last = false;
for (auto i = 0u; i < 5 && !last; ++i) {
auto alu = *reinterpret_cast<const latte::alu::Instruction*>(slots + slot);
auto unit = getUnit(units, alu);
const char *name = nullptr;
bool abs0 = false, abs1 = false;
auto &opcode = latte::alu::op2info[alu.op2.inst];
if (alu.word1.encoding == latte::alu::Encoding::OP2) {
opcode = latte::alu::op2info[alu.op2.inst];
name = opcode.name;
abs0 = !!alu.op2.src0Abs;
abs1 = !!alu.op2.src1Abs;
} else {
opcode = latte::alu::op3info[alu.op3.inst];
name = opcode.name;
}
beginLine(state);
if (i == 0) {
state.out << fmt::pad(state.group, groupCounterSize, '0');
} else {
state.out << std::string(groupCounterSize, ' ').c_str();
}
state.out
<< ' '
<< unitName[unit] << ": "
<< fmt::pad(name, instrNamePad, ' ');
if (alu.word1.encoding == latte::alu::Encoding::OP2 && alu.op2.writeMask == 0) {
state.out << "____";
} else {
writeAluSource(state, literalPtr, alu.word1.dstGpr, alu.word1.dstRel, alu.word1.dstChan, 0, false);
}
if (opcode.srcs > 0) {
state.out << ", ";
writeAluSource(state, literalPtr, alu.word0.src0Sel, alu.word0.src0Rel, alu.word0.src0Chan, alu.word0.src0Neg, abs0);
}
if (opcode.srcs > 1) {
state.out << ", ";
writeAluSource(state, literalPtr, alu.word0.src1Sel, alu.word0.src1Rel, alu.word0.src1Chan, alu.word0.src1Neg, abs1);
}
if (alu.word1.encoding == latte::alu::Encoding::OP2) {
if (alu.op2.updateExecuteMask) {
state.out << " UPDATE_EXECUTE_MASK";
}
if (alu.op2.updatePred) {
state.out << " UPDATE_PRED";
}
switch (alu.op2.omod) {
case latte::alu::OutputModifier::Divide2:
state.out << " OMOD_D2";
break;
case latte::alu::OutputModifier::Multiply2:
state.out << " OMOD_M2";
break;
case latte::alu::OutputModifier::Multiply4:
state.out << " OMOD_M4";
break;
}
} else {
if (opcode.srcs > 2) {
state.out << ", ";
writeAluSource(state, literalPtr, alu.op3.src2Sel, alu.op3.src2Rel, alu.op3.src2Chan, alu.op3.src2Neg, false);
}
}
switch (alu.word1.bankSwizzle) {
case latte::alu::BankSwizzle::Vec021:
state.out << " VEC_021";
break;
case latte::alu::BankSwizzle::Vec120:
state.out << " VEC_120";
break;
case latte::alu::BankSwizzle::Vec102:
state.out << " VEC_102";
break;
case latte::alu::BankSwizzle::Vec201:
state.out << " VEC_201";
break;
case latte::alu::BankSwizzle::Vec210:
state.out << " VEC_210";
break;
}
if (alu.word1.clamp) {
state.out << " CLAMP";
}
endLine(state);
// Count number of literal used
if (alu.word0.src0Sel == latte::alu::Source::SrcLiteral) {
literals = std::max(literals, alu.word0.src0Chan + 1);
}
if (alu.word0.src1Sel == latte::alu::Source::SrcLiteral) {
literals = std::max(literals, alu.word0.src1Chan + 1);
}
if ((alu.word1.encoding != latte::alu::Encoding::OP2) && (alu.op3.src2Sel == latte::alu::Source::SrcLiteral)) {
literals = std::max(literals, alu.op3.src2Chan + 1);
}
// Increase slot id
slot += 1;
last = !!alu.word0.last;
}
if (literals) {
slot += (literals + 1) >> 1;
}
state.group++;
}
decreaseIndent(state);
return true;
}
bool disassembleNormal(DisassembleState &state, latte::cf::inst id, latte::cf::Instruction &cf)
{
auto name = latte::cf::name[id];
switch (id) {
case latte::cf::TEX:
return disassembleTEX(state, id, cf);
case latte::cf::LOOP_START:
case latte::cf::LOOP_START_DX10:
case latte::cf::LOOP_START_NO_AL:
state.out
<< name
<< " FAIL_JUMP_ADDR(" << cf.word0.addr << ")";
endLine(state);
increaseIndent(state);
break;
case latte::cf::LOOP_END:
state.out
<< name
<< " PASS_JUMP_ADDR(" << cf.word0.addr << ")";
endLine(state);
decreaseIndent(state);
break;
case latte::cf::ELSE:
case latte::cf::JUMP:
state.out
<< name
<< " POP_CNT(" << cf.word1.popCount << ")"
<< " ADDR(" << cf.word0.addr << ")";
endLine(state);
break;
case latte::cf::NOP:
case latte::cf::CALL_FS:
case latte::cf::END_PROGRAM:
state.out
<< name;
endLine(state);
break;
case latte::cf::VTX:
case latte::cf::VTX_TC:
case latte::cf::LOOP_CONTINUE:
case latte::cf::LOOP_BREAK:
case latte::cf::POP_JUMP:
case latte::cf::CALL:
case latte::cf::RETURN:
case latte::cf::EMIT_VERTEX:
case latte::cf::EMIT_CUT_VERTEX:
case latte::cf::CUT_VERTEX:
case latte::cf::KILL:
case latte::cf::PUSH:
case latte::cf::PUSH_ELSE:
case latte::cf::POP:
case latte::cf::POP_PUSH:
case latte::cf::POP_PUSH_ELSE:
case latte::cf::WAIT_ACK:
case latte::cf::TEX_ACK:
case latte::cf::VTX_ACK:
case latte::cf::VTX_TC_ACK:
default:
assert(false);
break;
}
return true;
}
void
PrintDataBlockForGas(FILE *f, ParserState *P, int inlineAsm)
{
AST *ast;
int saveState;
if (gl_errors != 0)
return;
saveState = P->printLabelsVerbatim;
P->printLabelsVerbatim = 1;
if (inlineAsm) {
fprintf(f, "__asm__(\n");
fprintf(f, "\"\t\t.section .%s.cog, \\\"ax\\\"\\n\"\n",
P->basename);
}
/* print constant declarations */
PrintConstantsGas(f, P, inlineAsm);
if (inlineAsm) {
fprintf(f, "\"\t\t.compress off\\n\"\n");
}
startLine(f, inlineAsm);
fprintf(f, "..start");
endLine(f, inlineAsm);
for (ast = P->datblock; ast; ast = ast->right) {
/* print anything for start of line here */
startLine(f, inlineAsm);
switch (ast->kind) {
case AST_BYTELIST:
outputGasDataList(f, ".byte", ast->left);
break;
case AST_WORDLIST:
outputGasDataList(f, ".word", ast->left);
break;
case AST_LONGLIST:
outputGasDataList(f, ".long", ast->left);
break;
case AST_INSTRHOLDER:
outputGasInstruction(f, ast->left);
break;
case AST_IDENTIFIER:
outputGasLabel(f, ast);
break;
case AST_FILE:
ERROR(ast, "File directive not supported in GAS output");
break;
case AST_ORG:
outputGasDirective(f, ".org", ast->left);
break;
case AST_RES:
outputGasDirective(f, ".res", ast->left);
break;
case AST_FIT:
outputGasDirective(f, ".fit", ast->left ? ast->left : AstInteger(496));
break;
default:
ERROR(ast, "unknown element in data block");
break;
}
/* print end of line stuff here */
endLine(f, inlineAsm);
}
if (inlineAsm) {
fprintf(f, "\"\t\t.compress default\\n\"\n");
fprintf(f, "\"\t\t.text\\n\"\n");
fprintf(f, "\n);\n");
}
P->printLabelsVerbatim = saveState;
}
QString toListViewFormatterText::getFormattedString(toExportSettings &settings,
//const toResultModel *model);
const QAbstractItemModel * model)
{
int columns = model->columnCount();
int rows = model->rowCount();
QString output;
QVector<int> sizes(columns);
QVector<int> rlist = selectedRows(settings.selected);
QVector<int> clist = selectedColumns(settings.selected);
// must get widest length for each column
// zero array or (if writing headers, set their size)
for (int i = 0; i < columns - 1; i++)
{
if (settings.columnsHeader)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(i))
continue;
sizes[i] = model->headerData(
i,
Qt::Horizontal,
Qt::DisplayRole).toString().length();
}
else
sizes[i] = 0;
}
sizes[columns - 1] = 1;
// loop through model and get column widths
QModelIndex mi;
for (int row = 0; row < rows; row++)
{
for (int column = 0; column < columns - 1; column++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
continue;
if (!settings.rowsHeader && column == 0)
continue;
mi = model->index(row, column);
QVariant data = model->data(mi, Qt::EditRole);
QString v;
if (data.isNull())
v = "{null}";
else
v = data.toString();
int len = v.length();
if (len > sizes[column])
sizes[column] = len;
}
}
// write header data to fixed widths
if (settings.columnsHeader)
{
for (int column = 0; column < columns; column++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
continue;
if (!settings.rowsHeader && column == 0)
continue;
QString value = model->headerData(
column,
Qt::Horizontal,
Qt::DisplayRole).toString();
output += value;
for (int left = value.length(); left <= sizes[column]; left++)
output += ' ';
}
endLine(output);
// write ==== border
for (int column = 0; column < columns; column++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
continue;
if (!settings.rowsHeader && column == 0)
continue;
for (int left = 0; left < sizes[column]; left++)
output += '=';
output += ' ';
}
endLine(output);
}
// write data
for (int row = 0; row < rows; row++)
{
if (settings.rowsExport == toExportSettings::RowsSelected && !rlist.contains(row))
continue;
for (int column = 0; column < columns; column++)
{
if (settings.columnsExport == toExportSettings::ColumnsSelected && !clist.contains(column))
continue;
if (!settings.rowsHeader && column == 0)
continue;
mi = model->index(row, column);
QVariant data = model->data(mi, Qt::EditRole);
QString value;
if (data.isNull())
value = "{null}";
else
value = data.toString();
output += value;
for (int left = value.length(); left <= sizes[column]; left++)
output += ' ';
}
endLine(output);
}
return output;
}
void PrintHandler::comma()
{
_out << ',' << endLine();
}
