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))); }