clCallTipPtr clTernServer::ProcessCalltip(const wxString& output)
{
// Function calltip response:
// ================================
// {
// "type": "fn(f: fn(elt: ?, i: number), context?: ?)",
// "name": "Array.prototype.forEach",
// "exprName": "forEach",
// "url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/forEach",
// "doc": "Executes a provided function once per array element.",
// "origin": "ecma5"
// }
TagEntryPtrVector_t tags;
TagEntryPtr t(new TagEntry());
JSONRoot root(output);
wxString type = root.toElement().namedObject("type").toString();
int imgID;
wxString sig, retValue;
ProcessType(type, sig, retValue, imgID);
if(sig.IsEmpty()) {
return NULL;
}
t->SetSignature(sig);
t->SetReturnValue(retValue);
t->SetKind("function");
t->SetFlags(TagEntry::Tag_No_Signature_Format);
tags.push_back(t);
return new clCallTip(tags);
}
// Find the name of the DLL and inject it.
BOOL Inject( LPPROCESS_INFORMATION ppi )
{
DWORD len;
WCHAR dll[MAX_PATH];
int type;
#if (MYDEBUG > 0)
if (GetModuleFileNameEx( ppi->hProcess, NULL, dll, lenof(dll) ))
DEBUGSTR( L"%s", dll );
#endif
type = ProcessType( ppi );
if (type == 0)
return FALSE;
len = GetModuleFileName( NULL, dll, lenof(dll) );
while (dll[len-1] != '\\')
--len;
#ifdef _WIN64
wsprintf( dll + len, L"ANSI%d.dll", type );
if (type == 32)
InjectDLL32( ppi, dll );
else
InjectDLL64( ppi, dll );
#else
wcscpy( dll + len, L"ANSI32.dll" );
InjectDLL32( ppi, dll );
#endif
return TRUE;
}
// Inject code into the target process to load our DLL.
void Inject( LPPROCESS_INFORMATION pinfo, LPPROCESS_INFORMATION lpi,
DWORD dwCreationFlags )
{
int type = ProcessType( pinfo );
if (type != 0)
{
#ifdef _WIN64
if (type == 32)
{
hDllNameType[0] = '3';
hDllNameType[1] = '2';
InjectDLL32( pinfo );
}
else
{
hDllNameType[0] = '6';
hDllNameType[1] = '4';
InjectDLL64( pinfo );
}
#else
#ifdef W32ON64
if (type == 64)
{
TCHAR args[64];
STARTUPINFO si;
PROCESS_INFORMATION pi;
wcscpy( hDllNameType, L".exe" );
wsprintf( args, L"errout -P%lu:%lu",
pinfo->dwProcessId, pinfo->dwThreadId );
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
if (CreateProcess( hDllName, args, NULL, NULL, FALSE, 0, NULL, NULL,
&si, &pi ))
{
WaitForSingleObject( pi.hProcess, INFINITE );
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
}
wcscpy( hDllNameType, L"32.dll" );
}
else
#endif
InjectDLL32( pinfo );
#endif
}
if (!(dwCreationFlags & CREATE_SUSPENDED))
ResumeThread( pinfo->hThread );
if (lpi)
{
memcpy( lpi, pinfo, sizeof(PROCESS_INFORMATION) );
}
else
{
CloseHandle( pinfo->hProcess );
CloseHandle( pinfo->hThread );
}
}
void clTernServer::ProcessOutput(const wxString& output, wxCodeCompletionBoxEntry::Vec_t& entries)
{
// code completion response:
// ================================
// {
// "start": 78,
// "end": 78,
// "isProperty": true,
// "isObjectKey": false,
// "completions": [
// {
// "name": "concat",
// "type": "fn(other: [?])",
// "doc": "Returns a new array comprised of this array joined with other array(s) and/or value(s).",
// "url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/concat"
// },
// {
// "name": "every",
// "type": "fn(test: fn(elt: ?, i: number) -> bool, context?: ?) -> bool",
// "doc": "Tests whether all elements in the array pass the test implemented by the provided function.",
// "url": "https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/every"
// }]}
entries.clear();
JSONRoot root(output);
JSONElement completionsArr = root.toElement().namedObject("completions");
for(int i = 0; i < completionsArr.arraySize(); ++i) {
JSONElement item = completionsArr.arrayItem(i);
wxString name = item.namedObject("name").toString();
wxString doc = item.namedObject("doc").toString();
wxString url = item.namedObject("url").toString();
bool isKeyword = item.namedObject("isKeyword").toBool();
int imgId;
if(!isKeyword) {
doc = this->PrepareDoc(doc, url);
wxString type = item.namedObject("type").toString();
wxString sig, ret;
ProcessType(type, sig, ret, imgId);
// Remove double quotes
name.StartsWith("\"", &name);
name.EndsWith("\"", &name);
wxCodeCompletionBoxEntry::Ptr_t entry = wxCodeCompletionBoxEntry::New(name /* + sig*/, imgId);
entry->SetComment(doc);
entries.push_back(entry);
} else {
imgId = 17; // keyword
wxCodeCompletionBoxEntry::Ptr_t entry = wxCodeCompletionBoxEntry::New(name, imgId);
entries.push_back(entry);
}
}
}
//
// assert that the "index" of all types that should be checked is initially
// set to OMEGA
//
void TypeDependenceChecker::PartialOrder()
{
for (FileSymbol* file_symbol = (FileSymbol*) file_set.FirstElement();
file_symbol;
file_symbol = (FileSymbol*) file_set.NextElement())
{
for (unsigned j = 0; j < file_symbol -> types.Length(); j++)
{
TypeSymbol* type = file_symbol -> types[j];
if (type -> incremental_index == OMEGA)
ProcessType(type);
}
}
for (unsigned k = 0; k < type_trash_bin.Length(); k++)
{
TypeSymbol* type = type_trash_bin[k];
if (type -> incremental_index == OMEGA)
ProcessType(type);
}
}
// Inject code into the target process to load our DLL.
void Inject( LPPROCESS_INFORMATION pinfo, LPPROCESS_INFORMATION lpi,
DWORD dwCreationFlags )
{
int type = ProcessType( pinfo );
if (type != 0)
{
WCHAR dll[MAX_PATH];
#ifdef _WIN64
DWORD len = GetModuleFileName( GetModuleHandleA( "ANSI64.dll" ),
dll, lenof(dll) );
if (type == 32)
{
dll[len-6] = '3';
dll[len-5] = '2';
InjectDLL32( pinfo, dll );
}
else
{
InjectDLL64( pinfo, dll );
}
#else
GetModuleFileName( GetModuleHandleA( "ANSI32.dll" ), dll, lenof(dll) );
InjectDLL32( pinfo, dll );
#endif
}
if (!(dwCreationFlags & CREATE_SUSPENDED))
ResumeThread( pinfo->hThread );
if (lpi)
{
memcpy( lpi, pinfo, sizeof(PROCESS_INFORMATION) );
}
else
{
CloseHandle( pinfo->hProcess );
CloseHandle( pinfo->hThread );
}
}
void TypeDependenceChecker::ProcessType(TypeSymbol* type)
{
stack.Push(type);
int indx = stack.Size();
type -> incremental_index = indx;
// if dependents is reflexive make it non-reflexive - saves time !!!
type -> dependents -> RemoveElement(type);
type -> dependents_closure = new SymbolSet;
// compute reflexive transitive closure
type -> dependents_closure -> AddElement(type);
TypeSymbol* dependent;
for (dependent = (TypeSymbol*) type -> dependents -> FirstElement();
dependent;
dependent = (TypeSymbol*) type -> dependents -> NextElement())
{
if (dependent -> incremental_index == OMEGA)
ProcessType(dependent);
type -> incremental_index = Min(type -> incremental_index,
dependent -> incremental_index);
type -> dependents_closure ->
Union(*(dependent -> dependents_closure));
}
if (type -> incremental_index == indx)
{
TypeSymbol* scc_dependent;
do
{
scc_dependent = stack.Top();
scc_dependent -> incremental_index = CYCLE_INFINITY;
*(scc_dependent -> dependents_closure) =
*(type -> dependents_closure);
type_list.Next() = scc_dependent;
stack.Pop();
} while (scc_dependent != type);
}
}
OvrAggregate(const ProcessType& pt = ProcessType()) : ovr_(0), refItem_(0), pt_(pt)
{ /* */ }
/**
* Run the unfolding and correction task.
*
* The @a measuredFile is assumed to have the structure
*
* @verbatim
* /- ForwardMultSums (TCollection)
* |- [type] (TCollection)
* | |- [bin] (TCollection)
* | | `- rawDist (TH1)
* | |- [bin]
* | ...
* |- [type]
* ...
* @endverbatim
*
* and @a corrFile is assumed to have the structure
*
* @verbatim
* /- ForwardMultResults (TCollection)
* |- [type] (TCollection)
* | |- [bin] (TCollection)
* | | |- truth (TH1)
* | | |- truthAccepted (TH1)
* | | |- triggerVertex (TH1)
* | | `- response (TH2)
* | |- [bin]
* | ...
* |- [type]
* ...
* @endverbatim
*
* where @c [type] is one of <i>symmetric</i>, <i>positive</i>,
* <i>negative</i>, or <i>other</i>, and [bin] is the @f$ \eta@f$
* bin named like
*
* @verbatim
* [bin] := [eta_spec] _ [eta_spec]
* [eta_spec] := [sign_char] [integer_part] d [decimal_part]
* [sign_part] := p positive eta
* | m negative eta
* [integer_part] := [number]
* [decimal_part] := [number] [number]
* [number] := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
* @endverbatim
*
* That is, the bin @f$ -3\le\eta\ge3@f$ is labeled
* <b>m3d00_p3d00</b>, @f$ 0\le\eta\ge2.5@f$ is <b>p0d00_p2d50</b>
*
* @a measuredFile and @a corrFile can point to the same file. If
* @a corrFile is not specified, it is assumed that @a measuredFile
* has the expected @a corrFile @e in @e addition to the
* expected content of that file.
*
* @param measuredFile Name of file containing measured data
* @param corrFile Name of file containing correction data
* @param method Unfolding method to use
* @param regParam Regularization parameter
*/
void Run(const TString& measuredFile, const TString& corrFile,
const TString& method="Bayes", Double_t regParam=4)
{
// Get the input collections
if (measuredFile.IsNull()) {
Error("Run", "No measurements given");
return;
}
TCollection* mTop = GetTop(measuredFile, false);
TCollection* cTop = GetTop(corrFile.IsNull() ? measuredFile : corrFile,
true);
if (!mTop || !cTop) return;
// Get some info from the input collection
UShort_t sys;
UShort_t sNN;
ULong_t trig;
Double_t minZ;
Double_t maxZ;
GetParameter(mTop, "sys", sys);
GetParameter(mTop, "sNN", sNN);
GetParameter(mTop, "trigger", trig);
GetParameter(mTop, "minIpZ", minZ);
GetParameter(mTop, "maxIpZ", maxZ);
if (sys == 0 || sNN == 0)
Warning("Run", "System (%d) and/or collision energy (%d) unknown",
sys, sNN);
// Open the output file
TFile* out = TFile::Open("forward_unfolded.root", "RECREATE");
if (!out) {
Error("Run", "Failed to open output file");
return;
}
// Decode method option and store in file
TString meth(method);
UInt_t mId = MethodId(meth);
if (mId == 0xDeadBeef) return;
// Store information
SaveInformation(out,meth,mId,regParam,sys,sNN,trig,minZ,maxZ,
corrFile.IsNull());
// Load other data
TString savPath(gROOT->GetMacroPath());
gROOT->SetMacroPath(Form("%s:$(ALICE_PHYSICS)/PWGLF/FORWARD/analysis2/scripts",
gROOT->GetMacroPath()));
// Always recompile
if (!gROOT->GetClass("OtherPNch"))
gROOT->LoadMacro("OtherPNchData.C++");
gROOT->SetMacroPath(savPath);
// Loop over the input
const char* inputs[] = { "symmetric", "positive", "negative", 0 };
const char** pinput = inputs;
while (*pinput) {
TCollection* mInput = GetCollection(mTop, *pinput, false);
TCollection* cInput = GetCollection(cTop, *pinput, false);
if (mInput && cInput)
ProcessType(mInput, cInput, mId, regParam, out,
sys, sNN);
pinput++;
}
out->Write();
// out->ls();
out->Close();
SaveSummarize();
}
