DWORD FmodSoundEngine::ReadMusic(string filename)
{
if(pool.find(filename)!=pool.end())
return (DWORD)pool[filename];
FMOD::Sound *sound;
result = system->createStream(Ansi2UTF8(filename).data(), FMOD_ACCURATETIME|FMOD_MPEGSEARCH, NULL, &sound);
if(result!=FMOD_OK)
ShowMessage(StringTable(132)+" "+FMOD_ErrorString(result),2,0,32);
pool[filename] = sound;
if(!pitchDSP){
result = system->createDSPByType(FMOD_DSP_TYPE_PITCHSHIFT, &pitchDSP);
ERRCHECK(result);
result = pitchDSP->setParameterFloat(FMOD_DSP_PITCHSHIFT_FFTSIZE, systemIni.FMOD_DSP_FFT_WINDOW);
ERRCHECK(result);
result = pitchDSP->setActive(true);
ERRCHECK(result);
}
result = pitchDSP->disconnectAll(true, true);
ERRCHECK(result);
result = pitchDSP->setParameterFloat(FMOD_DSP_PITCHSHIFT_PITCH, 1.0f);
ERRCHECK(result);
return (DWORD)sound;
}
void webc_string_table_init(unsigned int size)
{
if (!gpWebcStringTable)
{
WEBC_NEW_VERBOSE(gpWebcStringTable, StringTable(size),"gpWebcStringTable");
}
}
PTGNode OutputRules ()
{ PTGNode res = PTGNULL;
RuleProdList rules = GrammarRules;
while (rules != NULLRuleProdList)
{ RuleProd rule = HeadRuleProdList (rules);
ProdSymbol lhs = HeadProdSymbolList (rule->prod);
ProdSymbolList rhs = TailProdSymbolList (rule->prod);
PTGNode rhsout = PTGNULL;
while (rhs != NULLProdSymbolList)
{ ProdSymbol symbol = HeadProdSymbolList (rhs);
switch (symbol->kind)
{ case IsProdLiteral:
rhsout =
PTGGramSeq
(rhsout,
PTGGramLiteral
(adaptLiterals(StringTable (symbol->u.literal))));
break;
case IsProdSymbol:
if (rule->islistof)
rhsout =
PTGGramAltSeq
(rhsout,
PTGGramSymbol
(StringTable (GetNameSym (symbol->u.s.symbolkey, 0))));
else
rhsout =
PTGGramSeq
(rhsout,
PTGGramSymbol
(StringTable (GetNameSym (symbol->u.s.symbolkey, 0))));
break;
case IsProdGenSymbol:
rhsout =
PTGGramSeq
(rhsout,
PTGGramGenSymbol
(StringTable (GetNameSym (symbol->u.s.symbolkey, 0))));
break;
}
rhs = TailProdSymbolList (rhs);
}
res =
PTGSeq
(res,
PTGGramRule
(StringTable (GetNameSym (rule->rulekey, 0)),
rule->islistof ?
PTGGramListof
(StringTable (GetNameSym (lhs->u.s.symbolkey, 0)),
rhsout) :
PTGGramProd
(StringTable (GetNameSym (lhs->u.s.symbolkey, 0)),
rhsout)));
rules = TailRuleProdList (rules);
}
return res;
}/* OutputRules */
/*
** Set the contents of a list and compensate for various motif problems
** associated with this apparently bizarre act. (It might be worth
** further investigation to better understand why these workarounds
** are necessary).
*/
static void setListItems(Widget w, XmString *strings, int nStrings)
{
XmString *st1;
/* Motif doesn't reset the selection when items are changed */
XmListDeselectAllItems(w);
/* .. and sometimes leaves stray scroll bars if nothing is in the list */
if (nStrings == 0) {
XtVaSetValues(w, XmNitems, st1=StringTable(1, " "),
XmNitemCount, 1, XmNsensitive, False, 0);
FreeStringTable(st1);
} else {
XtVaSetValues(w, XmNitems, strings, XmNitemCount, nStrings,
XmNsensitive, True, 0);
}
}
Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers,
bool WriteSymtab, object::Archive::Kind Kind,
bool Deterministic, bool Thin,
std::unique_ptr<MemoryBuffer> OldArchiveBuf) {
assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode");
SmallString<0> SymNamesBuf;
raw_svector_ostream SymNames(SymNamesBuf);
SmallString<0> StringTableBuf;
raw_svector_ostream StringTable(StringTableBuf);
Expected<std::vector<MemberData>> DataOrErr = computeMemberData(
StringTable, SymNames, Kind, Thin, Deterministic, NewMembers);
if (Error E = DataOrErr.takeError())
return E;
std::vector<MemberData> &Data = *DataOrErr;
if (!StringTableBuf.empty())
Data.insert(Data.begin(), computeStringTable(StringTableBuf));
// We would like to detect if we need to switch to a 64-bit symbol table.
if (WriteSymtab) {
uint64_t MaxOffset = 0;
uint64_t LastOffset = MaxOffset;
for (const auto &M : Data) {
// Record the start of the member's offset
LastOffset = MaxOffset;
// Account for the size of each part associated with the member.
MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size();
// We assume 32-bit symbols to see if 32-bit symbols are possible or not.
MaxOffset += M.Symbols.size() * 4;
}
// The SYM64 format is used when an archive's member offsets are larger than
// 32-bits can hold. The need for this shift in format is detected by
// writeArchive. To test this we need to generate a file with a member that
// has an offset larger than 32-bits but this demands a very slow test. To
// speed the test up we use this environment variable to pretend like the
// cutoff happens before 32-bits and instead happens at some much smaller
// value.
const char *Sym64Env = std::getenv("SYM64_THRESHOLD");
int Sym64Threshold = 32;
if (Sym64Env)
StringRef(Sym64Env).getAsInteger(10, Sym64Threshold);
// If LastOffset isn't going to fit in a 32-bit varible we need to switch
// to 64-bit. Note that the file can be larger than 4GB as long as the last
// member starts before the 4GB offset.
if (LastOffset >= (1ULL << Sym64Threshold)) {
if (Kind == object::Archive::K_DARWIN)
Kind = object::Archive::K_DARWIN64;
else
Kind = object::Archive::K_GNU64;
}
}
Expected<sys::fs::TempFile> Temp =
sys::fs::TempFile::create(ArcName + ".temp-archive-%%%%%%%.a");
if (!Temp)
return Temp.takeError();
raw_fd_ostream Out(Temp->FD, false);
if (Thin)
Out << "!<thin>\n";
else
Out << "!<arch>\n";
if (WriteSymtab)
writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf);
for (const MemberData &M : Data)
Out << M.Header << M.Data << M.Padding;
Out.flush();
// At this point, we no longer need whatever backing memory
// was used to generate the NewMembers. On Windows, this buffer
// could be a mapped view of the file we want to replace (if
// we're updating an existing archive, say). In that case, the
// rename would still succeed, but it would leave behind a
// temporary file (actually the original file renamed) because
// a file cannot be deleted while there's a handle open on it,
// only renamed. So by freeing this buffer, this ensures that
// the last open handle on the destination file, if any, is
// closed before we attempt to rename.
OldArchiveBuf.reset();
return Temp->keep(ArcName);
}
static void createBrowserOneDHistPanel(nTuBrowserInfo *nTuBr)
{
Arg args[50];
int ac;
XmString s1, *st1;
Widget dismissBtn, nbinLabel, lowEdgeLabel, highEdgeLabel, multLabel;
Widget histForm, ntupleForm, titleLabel, histLabel, ntupleLabel;
Widget ntupleCatLabel, ntupleTitleLabel;
ac = 0;
XtSetArg(args[ac], XmNautoUnmanage, False); ac++;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++;
OneDHistFormW = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
OneDHistShellW = XtParent(OneDHistFormW);
XtVaSetValues(OneDHistShellW, XmNtitle,
"One Dimensional Histogram Utility", 0);
AddMotifCloseCallback(XtParent(OneDHistFormW),
(XtCallbackProc)dismissOneDHistCB, NULL);
OneDHistCreateW = XtVaCreateManagedWidget("create1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Create"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 2,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 18, 0);
XmStringFree(s1);
XtAddCallback( OneDHistCreateW, XmNactivateCallback,
(XtCallbackProc)createOneDHistCB, (nTuBrowserInfo *) nTuBr );
OneDHistModifyW = XtVaCreateManagedWidget("modify1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Modify"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 20,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 40, 0);
XmStringFree(s1);
XtAddCallback( OneDHistModifyW, XmNactivateCallback,
(XtCallbackProc)modifyOneDHistCB, NULL);
OneDHistDeleteW = XtVaCreateManagedWidget("delete1DBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Delete"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 42,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 60, 0);
XmStringFree(s1);
XtAddCallback( OneDHistDeleteW, XmNactivateCallback,
(XtCallbackProc)deleteOneDHistCB, NULL);
dismissBtn = XtVaCreateManagedWidget("dismissBtn",
xmPushButtonGadgetClass, OneDHistFormW,
XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 80,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 98, 0);
XmStringFree(s1);
XtAddCallback(dismissBtn, XmNactivateCallback,
(XtCallbackProc)dismissOneDHistCB, NULL);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Number of bins:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,5); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
nbinLabel =
XmCreateLabelGadget(OneDHistFormW, "num1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(nbinLabel);
OneDHistNumBinsW = XtVaCreateManagedWidget("numBin1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 5,
XmNmaxLength, 5,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,nbinLabel, 0);
RemapDeleteKey(OneDHistNumBinsW);
XmTextSetString(OneDHistNumBinsW, "100");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Low Edge:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistNumBinsW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
lowEdgeLabel =
XmCreateLabelGadget(OneDHistFormW, "low1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(lowEdgeLabel);
OneDHistLowBinW = XtVaCreateManagedWidget("lowEdge1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,lowEdgeLabel, 0);
RemapDeleteKey(OneDHistLowBinW);
XmTextSetString(OneDHistLowBinW, "0.");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("High Edge:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistLowBinW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
highEdgeLabel =
XmCreateLabelGadget(OneDHistFormW, "high1Dbin", args, ac);
XmStringFree(s1);
XtManageChild(highEdgeLabel);
OneDHistHighBinW = XtVaCreateManagedWidget("highEdge1D",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,highEdgeLabel, 0);
RemapDeleteKey(OneDHistHighBinW);
XmTextSetString(OneDHistHighBinW, "1.");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Instance:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,OneDHistHighBinW); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistCreateW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
multLabel =
XmCreateLabelGadget(OneDHistFormW, "inst1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(multLabel);
OneDHistMultW = XtVaCreateManagedWidget("inst1DTw",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 10,
XmNmaxLength, 20,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistCreateW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,multLabel, 0);
RemapDeleteKey(OneDHistMultW);
XmTextSetString(OneDHistMultW, "All");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Title:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget,OneDHistNumBinsW); ac++;
XtSetArg(args[ac], XmNbottomOffset,3); ac++;
titleLabel =
XmCreateLabelGadget(OneDHistFormW, "title1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(titleLabel);
OneDHistTitleW = XtVaCreateManagedWidget("title1DTw",
xmTextWidgetClass, OneDHistFormW,
XmNcolumns, 80,
XmNmaxLength, 255,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget,OneDHistNumBinsW,
XmNbottomOffset,3,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget,titleLabel, 0);
RemapDeleteKey(OneDHistTitleW);
XmTextSetString(OneDHistTitleW, "Please enter a meaningful title here");
/*
** Now the list of 1D histograms.
*/
/* Create a form to hold the list and the top label */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
XtSetArg(args[ac], XmNleftOffset, 2); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
histForm = XmCreateForm(OneDHistFormW, "hist1DForm", args, ac);
XtManageChild(histForm);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple(
"One Dimensional Histogram Listing"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
histLabel =
XmCreateLabelGadget(histForm, "HIST1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(histLabel);
ac = 0;
XtSetArg(args[ac], XmNitems, (st1=StringTable(1,
"No histogram defined "))); ac++;
XtSetArg(args[ac], XmNitemCount, 1); ac++;
XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopWidget, histLabel); ac++;
XtSetArg(args[ac], XmNtopOffset, 0); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
XtSetArg(args[ac], XmNbottomOffset, 4); ac++;
OneDHistHistoListW = XmCreateScrolledList(histForm, "hist1DList", args,ac);
FreeStringTable(st1);
XtAddCallback(OneDHistHistoListW, XmNbrowseSelectionCallback,
(XtCallbackProc) oneDHistListCB, NULL);
XtManageChild(OneDHistHistoListW);
OneDHistSizeOfList = 10;
OneDHistNumberListed = 0;
OneDHistListedIDs = (int *) malloc(sizeof(int) * OneDHistSizeOfList);
/*
** Now the list of Ntuple Variables. Also a few Label to refer to the
** Ntuple category/title listed on the Main panel.
**
*/
/* Create a form to hold the list and the top label */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, histForm); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget, OneDHistTitleW); ac++;
XtSetArg(args[ac], XmNbottomOffset, 3); ac++;
XtSetArg(args[ac], XmNleftOffset, 6); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
ntupleForm = XmCreateForm(OneDHistFormW, "ntu1DForm", args, ac);
XtManageChild(ntupleForm);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Selected NTuple Synopsis"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
ntupleLabel =
XmCreateLabelGadget(ntupleForm, "NTU1DDlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Category:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
ntupleCatLabel =
XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleCatLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("None----------------------"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleLabel ); ac++;
OneDHistNtupleCategoryLabelW =
XmCreateLabelGadget(ntupleForm, "NTU1DCatlabel", args, ac);
XmStringFree(s1);
XtManageChild(OneDHistNtupleCategoryLabelW);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("Title:"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, ntupleCatLabel); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
ntupleTitleLabel =
XmCreateLabelGadget(ntupleForm, "NTU1Dlabel", args, ac);
XmStringFree(s1);
XtManageChild(ntupleTitleLabel);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
(s1=XmStringCreateSimple("None----------------------"))); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNleftOffset,3); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget,ntupleCatLabel ); ac++;
XtSetArg(args[ac], XmNtopOffset, 1); ac++;
OneDHistNtupleTitleLabelW =
XmCreateLabelGadget(ntupleForm, "NTU1DTitlabel", args, ac);
XmStringFree(s1);
XtManageChild(OneDHistNtupleTitleLabelW);
ac = 0;
XtSetArg(args[ac], XmNitems, (st1=StringTable(1, " "))); ac++;
XtSetArg(args[ac], XmNitemCount, 1); ac++;
XtSetArg(args[ac], XmNscrollBarDisplayPolicy, XmAS_NEEDED); ac++;
XtSetArg(args[ac], XmNvisibleItemCount, 10); ac++;
XtSetArg(args[ac], XmNselectionPolicy, XmBROWSE_SELECT); ac++;
XtSetArg(args[ac], XmNlistSizePolicy, XmCONSTANT); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopWidget, OneDHistNtupleTitleLabelW); ac++;
XtSetArg(args[ac], XmNtopOffset, 2); ac++;
XtSetArg(args[ac], XmNleftOffset, 3); ac++;
OneDHistVariableListW = XmCreateScrolledList(ntupleForm, "hist1DList", args,ac);
FreeStringTable(st1);
XtManageChild(OneDHistVariableListW);
FirstOneDHistogram = True;
XtManageChild(OneDHistFormW);
}
static void TestRule (char *s, DefTableKey key, CoordPtr coord)
{ int id = GetNameSym (key, 0);
char *name = id == 0 ? "unnamed" : StringTable(id);
printf ("%s rule %s in line %d\n", s, name, LineOf(*coord));
}
void AccumulateInherit (Environment globEnv) {
/* on entry:
The internal representations of all single accumulating computations
have been associated to the properties AccuLhs, AccuExecListe,
AccuDepList of the computation key.
The other Accu-properties are set.
The inheritance relation in the computation scopes are established.
The attribute types are determined.
on exit:
AccuInheritAtTreeSymbs collects for every TREE symbol the inherited
accumulated computations.
for every rule
the rule the accumulating rule computations are collected, and
for every symbol occurrence symocc
the accumulating computations are instantiated from the corresponding
TREE symbols.
*/
RuleProdList rules;
#ifdef ACCUTEST
printf("AccumulateInherit begin\n");
#endif
ex42 = newIntValue (42, ZeroCoord);
AccuInheritAtTreeSymbs (globEnv);
/* for each accu. attr. of each TREE symbol all computations inherited
from CLASS symbols are combined in the 3 accu properties of the TREE symbol
now
instantiate the computations from TREE symbols to symbol occurrences:
*/
/* step through all productions: */
rules = GrammarRules;
while (rules != NULLRuleProdList)
{ RuleProd rule = HeadRuleProdList (rules);
ProdSymbolList prod = rule->prod;
DefTableKey ruleKey = RuleKeyOfRuleProd (rule);
Binding rulecomp;
Environment ruleScope = GetLowerScope (ruleKey, NoEnv);
int symbolIndex = -1;
#ifdef ACCUTEST
printf ("RULE %s:\n",
StringTable (GetNameSym (ruleKey, 0)));
#endif
/* search the rule attributes for accumulating computations: */
rulecomp = DefinitionsOf(ruleScope);
while (rulecomp != NoBinding)
{ if (GetIsAccu (KeyOf (rulecomp), 0)) {
/* The computations for this attribute have been accumulated
in three properties; combine them into one assign: */
ResetCompRepr
(KeyOf (rulecomp), MakeAccuAssign (KeyOf (rulecomp)));
}
rulecomp = NextDefinition(rulecomp);
}
/* step through all nonterminal occurrences of this production: */
while (prod != NULLProdSymbolList) {
ProdSymbol sy = HeadProdSymbolList (prod);
DefTableKey symKey = sy->u.s.symbolkey;
if (sy->kind != IsProdLiteral && !GetIsTerm (symKey, 0)) {
Environment syCompScope = sy->u.s.scope;
Environment attrenv = GetAttrScope (symKey, NoEnv);
Binding attr = DefinitionsOf (attrenv);
symbolIndex++;
#ifdef ACCUTEST
printf (" symbol no. %d %s\n", symbolIndex,
StringTable (GetNameSym (symKey, 0)));
#endif
/* search all attributes of this symbol for accumulating ones: */
while (attr != NoBinding) {
if (GetHasAccuAsgn (KeyOf (attr), 0) &&
((symbolIndex > 0 &&
GetAttrClass (KeyOf (attr), NoClass) == INHClass) ||
(symbolIndex == 0 &&
GetAttrClass (KeyOf (attr), NoClass) == SYNTClass))) {
int attrId = IdnOf (attr);
/* symbol symKey has an accumulating attribute named attrId */
Binding symOccAttrComp = BindingInEnv (syCompScope, attrId);
Binding symAttrComp;
PExpr assign;
#ifdef ACCUTEST
printf (" attribute %s.%s\n",
StringTable (GetNameSym (symKey, 0)),
StringTable (GetNameSym (KeyOf (attr), 0)));
#endif
if (symOccAttrComp == NoBinding) {
/* no computation exists for this attr at all, create one: */
symOccAttrComp =
MakeAnAccuBinding (syCompScope, attr, ruleKey, ZeroCoord);
ResetCompRepr (KeyOf (symOccAttrComp),
newAssign (newAttrAccRule (sy, KeyOf (attr), 0, ZeroCoord),
ex42, ZeroCoord));
} else if (EnvOf (symOccAttrComp) != syCompScope) {
/* there are computations to be inherited */
/* there is no computation in the symbol occurrence,
we create one: */
symAttrComp = symOccAttrComp;
symOccAttrComp =
MakeAnAccuBinding (syCompScope, attr, ruleKey,
GetCoord (KeyOf (symAttrComp), ZeroCoord));
ResetInheritedFrom (KeyOf (symOccAttrComp), symAttrComp);
assign =
copyExpr (MakeAccuAssign (KeyOf (symAttrComp)));
instantiateExpr (assign, rule, sy);
ResetCompRepr (KeyOf (symOccAttrComp), assign);
ResetIsBottomUp (KeyOf(symOccAttrComp),
GetIsBottomUp (KeyOf(symAttrComp), 0));
} else {
symAttrComp = OverridesBinding (symOccAttrComp);
if (symAttrComp == NoBinding) {
/* there are no symbol computations,
combine the 3 properties in rule context:
*/
ResetCompRepr (KeyOf (symOccAttrComp),
MakeAccuAssign (KeyOf (symOccAttrComp)));
} else {
/* There are properties in symbol context (symAttrComp)
and 3 properties in the symbol occurrence (symOccAttrComp).
Instantiate the symbol computation:
*/
assign = copyExpr (MakeAccuAssign (KeyOf(symAttrComp)));
instantiateExpr (assign, rule, sy);
/* decompose assign onto symOccAttrComp: */
AccumulateExpr (KeyOf (symOccAttrComp), assign);
/* compose the 3 properties into an assign: */
assign = MakeAccuAssign (KeyOf (symOccAttrComp));
ResetCompRepr (KeyOf (symOccAttrComp), assign);
}
}
}/* an accumulating attribute of the symbol occurrence */
attr = NextDefinition (attr);
}/* the attributes of the symbol occurrence */
}/* is a non-terminal occurrence in the rule */
if (rule->islistof) break; /* lhs only */
prod = TailProdSymbolList (prod);
}/* all rule elements */
rules = TailRuleProdList (rules);
}/* all rules */
#ifdef ACCUTEST
printf("AccumulateInherit end\n");
#endif
}/* AccumulateInherit */
void AccuInheritAtTreeSymbs (Environment globEnv) {
/* on entry:
The internal representations of all single accumulating computations
have been associated to the properties AccuLhs, AccuExecList,
AccuDepList of the computation key.
The other Accu-properties are set.
The inheritance relations in the computation scopes are established.
The attribute types are determined.
on exit:
Each TREE symbol X has collected the accumulated computations from
any CLASS Symbol it inherits from, stored in its properties AccuLhs,
AccuExecList, AccuDepList of X's computation key.
*/
Binding symBind = DefinitionsOf (globEnv);
#ifdef ACCUTEST
printf ("AccuInheritAtTreeSymbs begin\n");
#endif
while (symBind != NoBinding) {
DefTableKey symKey = KeyOf (symBind);
if (GetIsNonterm (symKey, 0) && GetIsTreeSym (symKey, 0)) {
Environment attrenv = GetAttrScope (symKey, NoEnv);
Binding attr;
Environment symLowScope = GetLowerScope (symKey, NoEnv);
Environment symUpScope = GetUpperScope (symKey, NoEnv);
/* search all attributes of this symbol for accumulating ones: */
attr = DefinitionsOf (attrenv);
while (attr != NoBinding) {
if (InheritAttrAccu (attr)) {
int attrId = IdnOf (attr);
int attrCl = GetAttrClass (KeyOf (attr), NoClass);
Environment symScope =
(attrCl == SYNTClass ? symLowScope : symUpScope);
Binding inhComp, classSym;
Binding symComp = BindingInEnv (symScope, attrId);
#ifdef ACCUTEST
printf (" accu attribute %s.%s\n",
StringTable (GetNameSym (symKey, 0)),
StringTable (attrId));
#endif
if (symComp == NoBinding) {
/* no symbol computation, no inherited computation
create a symbol computation */
symComp =
MakeAnAccuBinding (symScope, attr, symKey,
GetCoord (symKey, ZeroCoord));
ResetAccuLhs (KeyOf (symComp),
newAttrAccSymb (symKey, KeyOf (attr), 0,
GetCoord (symKey, ZeroCoord)));
break; /* no further action for this attr */
} else if (EnvOf (symComp) == symScope) {
inhComp = OverridesBinding (symComp);
if (inhComp == NoBinding)
/* a symbol computation, no inherited computation */
break; /* no action for this attr */
/* else a symbol computation, an inherited computation */
} else {
/* no symbol computation, only inherited computations */
/* create a symbol computation: */
inhComp = symComp;
symComp =
MakeAnAccuBinding (symScope, attr, symKey,
GetCoord (symKey, ZeroCoord));
ResetInheritedFrom (KeyOf (symComp), inhComp);
ResetAccuLhs (KeyOf (symComp),
newAttrAccSymb (symKey, KeyOf (attr), 0,
GetCoord (symKey, ZeroCoord)));
}
/* There are inherited computations to be accumulated on symComp:
We step through all symbols and search in their
computation scopes inhCompScope which
Inheritsfrom (symScope, inhCompScope),
whether it has a computation to be accumulated on symComp.
*/
#ifdef ACCUTEST
printf (" there are inherited computations for %s.%s\n",
StringTable (GetNameSym (symKey, 0)),
StringTable (attrId));
#endif
classSym = DefinitionsOf (globEnv);
while (classSym != NoBinding) {
DefTableKey k = KeyOf (classSym);
if (k != symKey && GetIsSymbol (k, 0)) {
Environment inhCompScope =
(attrCl == SYNTClass ?
GetLowerScope (k, NoEnv) : GetUpperScope (k, NoEnv));
if (Inheritsfrom (symScope, inhCompScope)) {
/* inheritance relation holds */
#ifdef ACCUTEST
printf (" inherits from class %s\n", StringTable (GetNameSym (k, 0)));
#endif
Binding attrComp = DefinitionsOf (inhCompScope);
while (attrComp != NoBinding) {
if (IdnOf (attrComp) == attrId) {
if (!GetIsAccu (KeyOf (attrComp), 0)) {
message (ERROR,
CatStrInd ("Is inherited by an accumulating computation: ",
attrId), 0,
GetCoord (KeyOf(attrComp), ZeroCoord));
break;
} else if (GetIsTreeSym (k, 0)) {
message (ERROR,
CatStrInd ("Can not inherit from a TREE symbol: ",
attrId), 0, GetCoord (KeyOf(attrComp), ZeroCoord));
break;
} /* IsClass */
/* this computation is to be accumulated to symComp */
AccumulateAnInhComp (symComp, attrComp);
/* there is only one such computation in a scope: */
break;
}/* attr comps of this class symb */
attrComp = NextDefinition (attrComp);
}/* end search for a computation in a super scope */
}/* a super scope */
}/* a symbol */
classSym = NextDefinition (classSym);
}/* a global definition */
} /* accu attr */
attr = NextDefinition (attr);
}/* attributes */
}/* IsTreeSym */
symBind = NextDefinition (symBind);
}/* definitions */
#ifdef ACCUTEST
printf ("AccuInheritAtTreeSymbs end\n");
#endif
}/* AccuInheritAtTreeSymbs */
void WriteCmrFile()
{
if (CmrFile != NoKey)
write_results(StringTable(GetClpValue(CmrFile, 0)));
}
