void query_node(node_t *n, FILE *rsp)
{
if (n == NULL) {
fprintf(rsp, "null");
} else {
fprintf(rsp, "{");
fprintf(rsp, "\"id\":%u,", n->id);
fprintf(rsp, "\"splitType\":\"%s\",", SPLIT_TYPE_STR(n->split_type));
fprintf(rsp, "\"splitRatio\":%lf,", n->split_ratio);
fprintf(rsp, "\"birthRotation\":%i,", n->birth_rotation);
fprintf(rsp, "\"vacant\":%s,", BOOL_STR(n->vacant));
fprintf(rsp, "\"hidden\":%s,", BOOL_STR(n->hidden));
fprintf(rsp, "\"sticky\":%s,", BOOL_STR(n->sticky));
fprintf(rsp, "\"private\":%s,", BOOL_STR(n->private));
fprintf(rsp, "\"locked\":%s,", BOOL_STR(n->locked));
fprintf(rsp, "\"presel\":");
query_presel(n->presel, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"rectangle\":");
query_rectangle(n->rectangle, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"firstChild\":");
query_node(n->first_child, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"secondChild\":");
query_node(n->second_child, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"client\":");
query_client(n->client, rsp);
fprintf(rsp, "}");
}
}
void plotOptions__fprint(FILE* STAT_FP, const struct PlotOptions* plotOptions)
{
ATTRIBUTE_BEGIN("plotOptions");
if(plotOptions->chart != NULL)
{
ATTRIBUTE_BEGIN(chart_type_str[plotOptions->chart->type]);
ATTRIBUTE_BEGIN("dataLabels");
if(plotOptions->dataLabels_enabled != PLOTOPTIONS_UNSET)
STAT_PRINTF("enabled:%s,", BOOL_STR(plotOptions->dataLabels_enabled));
ATTRIBUTE_END;
if(plotOptions->enableMouseTracking != PLOTOPTIONS_UNSET)
STAT_PRINTF("enableMouseTracking:%s,", BOOL_STR(plotOptions->enableMouseTracking));
ATTRIBUTE_END;
}
ATTRIBUTE_BEGIN("series");
if(plotOptions->series_stacking != PLOTOPTIONS_UNSET)
STAT_PRINTF("stacking: '%s',", plotoptions_series_stacking_str[plotOptions->series_stacking]);
ATTRIBUTE_END;
ATTRIBUTE_END;
}
void RfPrintTrackVerify(FILE *out,
const char *spacer,
const track_file_verify_t *verify)
{
char spacer2[128];
fprintf(out, "%sVerification params :\n", spacer);
fprintf(out, "%s forecast_lead_time (secs) : %ld\n", spacer,
(long) verify->forecast_lead_time);
fprintf(out, "%s forecast_lead_time_margin (secs) : %ld\n", spacer,
(long) verify->forecast_lead_time_margin);
fprintf(out, "%s forecast_min_history (secs) : %ld\n", spacer,
(long) verify->forecast_min_history);
fprintf(out, "%s verify_before_forecast_time : %s\n", spacer,
BOOL_STR(verify->verify_before_forecast_time));
fprintf(out, "%s verify_after_track_dies : %s\n", spacer,
BOOL_STR(verify->verify_after_track_dies));
sprintf(spacer2, "%s ", spacer);
TITAN_print_grid(out, spacer2, &verify->grid);
}
void query_monitor(monitor_t *m, FILE *rsp)
{
fprintf(rsp, "{");
fprintf(rsp, "\"name\":\"%s\",", m->name);
fprintf(rsp, "\"id\":%u,", m->id);
fprintf(rsp, "\"randrId\":%u,", m->randr_id);
fprintf(rsp, "\"wired\":%s,", BOOL_STR(m->wired));
fprintf(rsp, "\"stickyCount\":%i,", m->sticky_count);
fprintf(rsp, "\"windowGap\":%i,", m->window_gap);
fprintf(rsp, "\"borderWidth\":%u,", m->border_width);
fprintf(rsp, "\"focusedDesktopId\":%u,", m->desk->id);
fprintf(rsp, "\"padding\":");
query_padding(m->padding, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"rectangle\":");
query_rectangle(m->rectangle, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"desktops\":");
fprintf(rsp, "[");
for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
query_desktop(d, rsp);
if (d->next != NULL) {
fprintf(rsp,",");
}
}
fprintf(rsp, "]");
fprintf(rsp, "}");
}
void RfPrintTrackEntry(FILE *out,
const char *spacer,
si32 entry_num,
const track_file_params_t *params,
const track_file_entry_t *entry)
{
char spacer2[128];
sprintf(spacer2, "%s ", spacer);
fprintf(out, "%sENTRY NUMBER : %ld\n", spacer, (long) entry_num);
fprintf(out, "%s time : %s\n", spacer, utimstr(entry->time));
fprintf(out, "%s time_origin : %s\n", spacer,
utimstr(entry->time_origin));
fprintf(out, "%s scan_origin in storm file : %ld\n", spacer,
(long) entry->scan_origin);
fprintf(out, "%s scan_num in storm file : %ld\n", spacer,
(long) entry->scan_num);
fprintf(out, "%s storm_num in storm file : %ld\n", spacer,
(long) entry->storm_num);
fprintf(out, "%s simple_track_num : %ld\n", spacer,
(long) entry->simple_track_num);
fprintf(out, "%s complex_track_num : %ld\n", spacer,
(long) entry->complex_track_num);
fprintf(out, "%s history_in_scans : %ld\n", spacer,
(long) entry->history_in_scans);
fprintf(out, "%s history_in_secs : %ld\n", spacer,
(long) entry->history_in_secs);
fprintf(out, "%s duration_in_scans : %ld\n", spacer,
(long) entry->duration_in_scans);
fprintf(out, "%s duration_in_secs : %ld\n", spacer,
(long) entry->duration_in_secs);
fprintf(out, "%s forecast_valid : %s\n", spacer,
BOOL_STR(entry->forecast_valid));
fprintf(out, "%s prev_entry_offset : %ld\n", spacer,
(long) entry->prev_entry_offset);
fprintf(out, "%s this_entry_offset : %ld\n", spacer,
(long) entry->this_entry_offset);
fprintf(out, "%s next_entry_offset : %ld\n", spacer,
(long) entry->next_entry_offset);
fprintf(out, "\n");
RfPrintForecastProps(out, "Entry forecast:",
spacer2, params,
&entry->dval_dt);
return;
}
void RfPrintTrackEntryXML(FILE *out,
const char *spacer,
si32 entry_num,
const track_file_params_t *params,
const track_file_entry_t *entry)
{
char spacer2[128];
sprintf(spacer2, "%s ", spacer);
fprintf(out, "%s <time_track><unixtime> %d </unixtime></time_track>\n", spacer, entry->time);
fprintf(out, "%s <time_origin><unixtime> %d </unixtime></time_origin>\n", spacer,
entry->time_origin);
fprintf(out, "%s <scan_origin_in_storm_file> %ld </scan_origin_in_storm_file>\n", spacer,
(long) entry->scan_origin);
fprintf(out, "%s <scan_num_in_storm_file> %ld </scan_num_in_storm_file>\n", spacer,
(long) entry->scan_num);
fprintf(out, "%s <storm_num_in_storm_file> %ld </storm_num_in_storm_file>\n", spacer,
(long) entry->storm_num);
fprintf(out, "%s <simple_track_num> %ld </simple_track_num>\n", spacer,
(long) entry->simple_track_num);
fprintf(out, "%s <complex_track_num> %ld </complex_track_num>\n", spacer,
(long) entry->complex_track_num);
fprintf(out, "%s <history_in_scans> %ld </history_in_scans>\n", spacer,
(long) entry->history_in_scans);
fprintf(out, "%s <history_in_secs> %ld </history_in_secs>\n", spacer,
(long) entry->history_in_secs);
fprintf(out, "%s <duration_in_scans> %ld </duration_in_scans>\n", spacer,
(long) entry->duration_in_scans);
fprintf(out, "%s <duration_in_secs> %ld </duration_in_secs>\n", spacer,
(long) entry->duration_in_secs);
fprintf(out, "%s <forecast_valid> %s </forecast_valid>\n", spacer,
BOOL_STR(entry->forecast_valid));
/* irrelevant!
fprintf(out, "%s <prev_entry_offset> %ld </prev_entry_offset>\n", spacer,
(long) entry->prev_entry_offset);
fprintf(out, "%s <this_entry_offset> %ld </this_entry_offset>\n", spacer,
(long) entry->this_entry_offset);
fprintf(out, "%s <next_entry_offset> %ld </next_entry_offset>\n", spacer,
(long) entry->next_entry_offset);
*/
fprintf(out, "\n");
RfPrintForecastPropsXML(out, "Entry forecast",
spacer2, params,
&entry->dval_dt);
return;
}
bool
ServerPasswd::validate(const char *type, const char *c_uname, const char *s_mnt_name, const char *s_nonce,
const char *c_pwd, string& base)
{
ASSERT(c_uname);
ASSERT(s_mnt_name);
ASSERT(s_nonce);
ASSERT(c_pwd);
_DEBUG("VALIDATE: uname=%s mnt_name=%s nonce=%s pwd=%s",
c_uname, s_mnt_name, s_nonce, c_pwd);
struct server_passwd_entry e;
string hash = userToKey(c_uname, s_mnt_name);
ScopedMutex lock(&pwd_mutex);
ServerPasswd p(Config::instance()->pwd_file().c_str());
bool found = p.getEntry(hash, e);
_DEBUG("VALIDATE hash=%s found=%s", hash.c_str(), BOOL_STR(found));
if (found)
{
time_t now = time(0);
if (e.expires > 0 && (uint64_t) now > e.expires)
{
return false;
}
#if 1
// CryptoUtils password check
if (!passwd_check(type, e.passwd, s_nonce, c_pwd))
{
return false;
}
#else
// nonce + pwd == c_pwd
string pwd = s_nonce;
pwd += b64std2inet(e.passwd);
#ifndef OLD_KEY
make_hash64(type, pwd, pwd);
#else
sha2_digest_t digest;
make_sha2(pwd, &digest);
sha2_base64(&digest, pwd);
#endif
_DEBUG("VALIDATE: new_pwd=%s entry_pwd=%s", pwd.c_str(), e.passwd.c_str());
if (b64inet2std(c_pwd) != b64inet2std(pwd))
{
return false;
}
#endif
base = e.base;
}
return found;
}
void query_client(client_t *c, FILE *rsp)
{
if (c == NULL) {
fprintf(rsp, "null");
} else {
fprintf(rsp, "{");
fprintf(rsp, "\"className\":\"%s\",", c->class_name);
fprintf(rsp, "\"instanceName\":\"%s\",", c->instance_name);
fprintf(rsp, "\"borderWidth\":%u,", c->border_width);
fprintf(rsp, "\"state\":\"%s\",", STATE_STR(c->state));
fprintf(rsp, "\"lastState\":\"%s\",", STATE_STR(c->last_state));
fprintf(rsp, "\"layer\":\"%s\",", LAYER_STR(c->layer));
fprintf(rsp, "\"lastLayer\":\"%s\",", LAYER_STR(c->last_layer));
fprintf(rsp, "\"urgent\":%s,", BOOL_STR(c->urgent));
fprintf(rsp, "\"shown\":%s,", BOOL_STR(c->shown));
fprintf(rsp, "\"tiledRectangle\":");
query_rectangle(c->tiled_rectangle, rsp);
fprintf(rsp,",");
fprintf(rsp, "\"floatingRectangle\":");
query_rectangle(c->floating_rectangle, rsp);
fprintf(rsp, "}");
}
}
void MDVPrintRadarGrid(FILE *out,
char *spacer,
MDV_radar_grid_t *grid)
{
fprintf(out, "%sMDV radar grid parameters : \n", spacer);
fprintf(out, "%s nbytes_char : %ld\n",
spacer, (long) grid->nbytes_char);
fprintf(out, "%s grid latitude : %g\n",
spacer, grid->latitude);
fprintf(out, "%s grid longitude : %g\n",
spacer, grid->longitude);
fprintf(out, "%s grid rotation : %g\n",
spacer, grid->rotation);
fprintf(out, "%s nx, ny, nz : %d, %d, %d\n",
spacer,
grid->nx, grid->ny, grid->nz);
fprintf(out, "%s minx, miny, minz : %g, %g, %g\n",
spacer,
grid->minx, grid->miny, grid->minz);
fprintf(out, "%s dx, dy, dz : %g, %g, %g\n", spacer,
grid->dx, grid->dy, grid->dz);
fprintf(out, "%s radarx, radary, radarz : %g, %g, %g\n",
spacer,
grid->radarx, grid->radary, grid->radarz);
fprintf(out, "%s dz_constant: %s\n", spacer,
BOOL_STR(grid->dz_constant));
fprintf(out, "%s x units : %s\n", spacer, grid->unitsx);
fprintf(out, "%s y units : %s\n", spacer, grid->unitsy);
fprintf(out, "%s z units : %s\n", spacer, grid->unitsz);
}
int query_init_status_format(ClientResultPrinter print, void *results, uint16_t results_length) {
if (results_length != sizeof(InitStatus)) return 0;
InitStatus *res = (InitStatus*) results;
return print("Initialized: %s, Software resets: %i, Unclean resets: %i",
BOOL_STR(res->initialized), res->software_resets, res->unclean_resets);
}
HRESULT SymBase::GetInfoTable( SymbolInfoTable &InfoTable )
{
HRESULT hr;
ULONG SymULONG;
LPCWSTR SymStr;
BSTR SymBStr;
BOOL SymBOOL;
IDiaSymbol *SymSymbol;
IDiaEnumSymbols *SymEnum;
BOOL TableRet;
CString Tmp;
//
// Children
//
hr = Self()->findChildren(SymTagNull, NULL, nsNone, &SymEnum);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CHILDREN, BOOL_STR(SymEnum != NULL));
VERIFY_EXP(TableRet);
SymEnum->Release();
}
//
// access
//
hr = Self()->get_access(&SymULONG);
if (HR_OK(hr)) {
SymStr = GetAccessStr(SymULONG);
TableRet = InfoTable.Add(SYMBOL_ACCESS, SymStr);
VERIFY_EXP(TableRet);
}
//
// addressOffset
//
hr = Self()->get_addressOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ADDRESSOFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// addressSection
//
hr = Self()->get_addressSection(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ADDRESSSECTION, Tmp);
VERIFY_EXP(TableRet);
}
//
// addressTaken
//
hr = Self()->get_addressTaken(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ADDRESSTAKEN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// age
//
hr = Self()->get_age(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_AGE, Tmp);
VERIFY_EXP(TableRet);
}
//
// arrayIndexType
//
hr = Self()->get_arrayIndexType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// arrayIndexTypeId
//
hr = Self()->get_arrayIndexTypeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// backEndMajor (Not implement)
//
//
// backEndMinor (Not implement)
//
//
// backEndBuild (Not implement)
//
//
// baseType
//
hr = Self()->get_baseType(&SymULONG);
if (HR_OK(hr)) {
SymStr = GetBaseTypeStr(SymULONG, 0);
TableRet = InfoTable.Add(SYMBOL_BASETYPE, SymStr);
VERIFY_EXP(TableRet);
}
//
// bitPosition
//
hr = Self()->get_bitPosition(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_BITPOSITION, Tmp);
VERIFY_EXP(TableRet);
}
//
// callingConvention
//
hr = Self()->get_callingConvention(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CALLINGCONVENTION, GetCallingConventionStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// classParent
//
hr = Self()->get_classParent(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CLASSPARENT, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// classParentId
//
hr = Self()->get_classParentId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_CLASSPARENTID, Tmp);
VERIFY_EXP(TableRet);
}
//
// code
//
hr = Self()->get_code(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CODE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// compilerGenerated
//
hr = Self()->get_compilerGenerated(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_COMPILERGENERATED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// compilerName
//
hr = Self()->get_compilerName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_COMPILERNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// constructor
//
hr = Self()->get_constructor(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONSTRUCTOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// container
//
hr = Self()->get_container(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONTAINER, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// constType
//
hr = Self()->get_constType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CONSTTYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// count
//
hr = Self()->get_count(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_COUNT, Tmp);
VERIFY_EXP(TableRet);
}
//
// customCallingConvention
//
hr = Self()->get_customCallingConvention(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_CUSTOMCALLINGCONVENTION, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// dataBytes (Not implement)
//
//
// dataKind
//
hr = Self()->get_dataKind(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_DATAKIND, GetDataKindStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// editAndContinueEnabled
//
hr = Self()->get_editAndContinueEnabled(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_EDITANDCONTINUEENABLED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// farReturn
//
hr = Self()->get_farReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// frontEndMajor (Not implement)
//
//
// frontEndMinor (Not implement)
//
//
// frontEndBuild (Not implement)
//
//
// function
//
hr = Self()->get_function(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// guid
//
GUID SymGuid;
hr = Self()->get_guid(&SymGuid);
if (HR_OK(hr)) {
Tmp.Format(L"{%08X-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X} ",
SymGuid.Data1, SymGuid.Data2, SymGuid.Data3, SymGuid.Data4[0],
SymGuid.Data4[1], SymGuid.Data4[2], SymGuid.Data4[3],
SymGuid.Data4[4], SymGuid.Data4[5],
SymGuid.Data4[6], SymGuid.Data4[7]);
TableRet = InfoTable.Add(SYMBOL_GUID, Tmp);
VERIFY_EXP(TableRet);
}
//
// hasAlloca
//
hr = Self()->get_hasAlloca(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASALLOCA, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasAssignmentOperator
//
hr = Self()->get_hasAssignmentOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASASSIGNMENTOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasCastOperator
//
hr = Self()->get_hasCastOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASCASTOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasDebugInfo
//
hr = Self()->get_hasDebugInfo(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASDEBUGINFO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasEH
//
hr = Self()->get_hasEH(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASEH, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasEHa
//
hr = Self()->get_hasEHa(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASEHA, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasInlAsm
//
hr = Self()->get_hasInlAsm(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASINLASM, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasLongJump
//
hr = Self()->get_hasLongJump(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASLONGJUMP, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasManagedCode
//
hr = Self()->get_hasManagedCode(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASMANAGEDCODE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasNestedTypes
//
hr = Self()->get_hasNestedTypes(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASNESTEDTYPES, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSecurityChecks
//
hr = Self()->get_hasSecurityChecks(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSECURITYCHECKS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSEH
//
hr = Self()->get_hasSEH(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSEH, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// hasSetJump
//
hr = Self()->get_hasSetJump(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_HASSETJUMP, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// indirectVirtualBaseClass
//
hr = Self()->get_indirectVirtualBaseClass(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INDIRECTVIRTUALBASECLASS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// inlSpec
//
hr = Self()->get_inlSpec(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INLSPEC, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// interruptReturn
//
hr = Self()->get_interruptReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INTERRUPTRETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// intro
//
hr = Self()->get_intro(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_INTRO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isAggregated
//
hr = Self()->get_isAggregated(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISAGGREGATED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isCTypes
//
hr = Self()->get_isCTypes(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISCTYPES, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isCVTCIL
//
hr = Self()->get_isCVTCIL(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISCVTCIL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isDataAligned
//
hr = Self()->get_isDataAligned(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISDATAALIGNED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isHotpatchable
//
hr = Self()->get_isHotpatchable(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISHOTPATCHABLE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isLTCG
//
hr = Self()->get_isLTCG(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISLTCG, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isMSILNetmodule
//
hr = Self()->get_isMSILNetmodule(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISMSILNETMODULE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isNaked
//
hr = Self()->get_isNaked(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISNAKED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isSplitted
//
hr = Self()->get_isSplitted(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSPLITTED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isStatic
//
hr = Self()->get_isStatic(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSTATIC, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// isStripped
//
hr = Self()->get_isStripped(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_ISSTRIPPED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// language
//
hr = Self()->get_language(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LANGUAGE, GetLanguageStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// length
//
ULONGLONG SymULONGLONG;
hr = Self()->get_length(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_LENGTH, Tmp);
VERIFY_EXP(TableRet);
}
//
// lexicalParent
//
hr = Self()->get_lexicalParent(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LEXICALPARENT, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// lexicalParentId
//
hr = Self()->get_lexicalParentId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_LEXICALPARENTID, Tmp);
VERIFY_EXP(TableRet);
}
//
// libraryName
//
hr = Self()->get_libraryName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LIBRARYNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// liveLVarInstances (Not implement)
//
//
// locationType
//
hr = Self()->get_locationType(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_LOCATIONTYPE, GetLocationTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// lowerBound (Not implement)
//
//
// lowerBoundId (Not implement)
//
//
// machineType
//
hr = Self()->get_machineType(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MACHINETYPE, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// managed
//
hr = Self()->get_managed(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MANAGED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// msil
//
hr = Self()->get_msil(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_MSIL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// name
//
hr = Self()->get_name(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// nested
//
hr = Self()->get_nested(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NESTED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noInline
//
hr = Self()->get_noInline(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOINLINE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noReturn
//
hr = Self()->get_noReturn(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NORETURN, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// noStackOrdering
//
hr = Self()->get_noStackOrdering(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOSTACKORDERING, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// notReached
//
hr = Self()->get_notReached(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_NOTREACHED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// objectPointerType
//
hr = Self()->get_objectPointerType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OBJECTPOINTERTYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// oemId
//
hr = Self()->get_oemId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_OEMID, Tmp);
VERIFY_EXP(TableRet);
}
//
// oemSymbolId
//
hr = Self()->get_oemSymbolId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, Tmp);
VERIFY_EXP(TableRet);
}
//
// offset
//
LONG SymLONG;
hr = Self()->get_offset(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_OFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// optimizedCodeDebugInfo
//
hr = Self()->get_optimizedCodeDebugInfo(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OPTIMIZEDCODEDEBUGINFO, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// overloadedOperator
//
hr = Self()->get_overloadedOperator(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OVERLOADEDOPERATOR, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// packed
//
hr = Self()->get_packed(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_PACKED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// platform
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// pure
//
hr = Self()->get_pure(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_PURE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// rank (Not implement)
//
//
// reference
//
hr = Self()->get_reference(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_REFERENCE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// registerId
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_REGISTERID, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// relativeVirtualAddress
//
hr = Self()->get_platform(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_RELATIVEVIRTUALADDRESS, GetMachineTypeStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// scoped
//
hr = Self()->get_scoped(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SCOPED, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// signature
//
hr = Self()->get_signature(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SIGNATURE, Tmp);
VERIFY_EXP(TableRet);
}
//
// slot
//
hr = Self()->get_slot(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SLOT, Tmp);
VERIFY_EXP(TableRet);
}
//
// sourceFileName
//
hr = Self()->get_sourceFileName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SOURCEFILENAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// symbolsFileName
//
hr = Self()->get_symbolsFileName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SYMBOLSFILENAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// symIndexId
//
hr = Self()->get_symIndexId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
VERIFY_EXP(TableRet);
}
//
// symTag
//
hr = Self()->get_symTag(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_SYMTAG, GetSymTagStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// targetOffset
//
hr = Self()->get_targetOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetRelativeVirtualAddress
//
hr = Self()->get_targetRelativeVirtualAddress(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TARGETRELATIVEVIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetSection
//
hr = Self()->get_targetSection(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TARGETSECTION, Tmp);
VERIFY_EXP(TableRet);
}
//
// targetVirtualAddress
//
hr = Self()->get_targetVirtualAddress(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_TARGETVIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// thisAdjust
//
hr = Self()->get_thisAdjust(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
VERIFY_EXP(TableRet);
}
//
// thunkOrdinal
//
hr = Self()->get_thunkOrdinal(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
VERIFY_EXP(TableRet);
}
//
// timeStamp
//
hr = Self()->get_timeStamp(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TIMESTAMP, Tmp);
VERIFY_EXP(TableRet);
}
//
// token
//
hr = Self()->get_token(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TOKEN, Tmp);
VERIFY_EXP(TableRet);
}
//
// type
//
hr = Self()->get_type(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_TYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// typeId
//
hr = Self()->get_typeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_TYPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// types (Not implement)
//
//
// typeIds (Not implement)
//
//
// udtKind
//
hr = Self()->get_udtKind(&SymULONG);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UDTKIND, GetUdtKindStr(SymULONG));
VERIFY_EXP(TableRet);
}
//
// unalignedType
//
hr = Self()->get_unalignedType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UNALIGNEDTYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// undecoratedName
//
hr = Self()->get_undecoratedName(&SymBStr);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_UNDECORATEDNAME, SymBStr);
VERIFY_EXP(TableRet);
}
//
// undecoratedNameEx (Not implement)
//
//
// upperBound (Not implement)
//
//
// upperBoundId (Not implement)
//
//
// value
//
VARIANT SymVar;
SymVar.vt = VT_EMPTY;
hr = Self()->get_value(&SymVar);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VALUE, L"TRUE");
VERIFY_EXP(TableRet);
}
//
// virtual
//
hr = Self()->get_virtual(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUAL, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// virtualAddress
//
hr = Self()->get_virtualAddress(&SymULONGLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%0.16I64X", SymULONGLONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALADDRESS, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseClass
//
hr = Self()->get_virtualBaseClass(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASECLASS, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
//
// virtualBaseDispIndex
//
hr = Self()->get_virtualBaseDispIndex(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEDISPINDEX, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseOffset
//
hr = Self()->get_virtualBaseOffset(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEOFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBasePointerOffset
//
hr = Self()->get_virtualBasePointerOffset(&SymLONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymLONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEPOINTEROFFSET, Tmp);
VERIFY_EXP(TableRet);
}
//
// virtualBaseTableType
//
hr = Self()->get_virtualBaseTableType(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALBASETABLETYPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// virtualTableShape
//
hr = Self()->get_virtualTableShape(&SymSymbol);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPE, BOOL_STR(SymSymbol != NULL));
VERIFY_EXP(TableRet);
SymSymbol->Release();
}
//
// virtualTableShapeId
//
hr = Self()->get_virtualTableShapeId(&SymULONG);
if (HR_OK(hr)) {
Tmp.Format(L"%08X", SymULONG);
TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPEID, Tmp);
VERIFY_EXP(TableRet);
}
//
// volatileType
//
hr = Self()->get_volatileType(&SymBOOL);
if (HR_OK(hr)) {
TableRet = InfoTable.Add(SYMBOL_VOLATILETYPE, BOOL_STR(SymBOOL));
VERIFY_EXP(TableRet);
}
#ifdef DEBUG_PRINT
DisplayInfo(InfoTable);
#endif
return S_OK;
}
