void pdivuw() { enum { _end1, _end2 }; #define macro(_idx, _endlbl) \ mov32_reg_mem(_ecx, _GPR_D(_rt, _idx)); \ tst32_reg_reg(_ecx, _ecx); \ jz(_endlbl); \ xor32_reg_reg(_edx, _edx); \ mov32_eax_mem(_GPR_D(_rs, _idx)); \ div_reg(_ecx); \ mov32_reg_reg(_ecx, _edx); \ cdq(); \ mov32_mem_reg((u32)&g_cpu->m_lo.d[_idx], _eax); \ mov32_mem_reg((u32)&g_cpu->m_lo.d[_idx + 1], _edx); \ mov32_reg_reg(_eax, _ecx); \ cdq(); \ mov32_mem_reg((u32)&g_cpu->m_hi.d[_idx], _eax); \ mov32_mem_reg((u32)&g_cpu->m_hi.d[_idx + 1], _edx); macro(0, _end1); // 63-0 LABEL_DEF(_end1); macro(2, _end2); // 127-64 LABEL_DEF(_end2); #undef macro }
// // SLOT // Effect: change the macro expansion referenced by a control entry to the named variable. // void QEpicsAcqLocal::defVariable( const QString &varName, const QString &scan, const QString &type, int varIndex) { acqScan_t *sc; char **nameAddr = NULL; if( master == NULL) return; sc = lookup_acqScan( scan.toAscii().constData(), master); if( sc == NULL) return; if( type == "first" || type == "start" ) nameAddr = &sc->acqControlList[varIndex].startMacro; else if( type == "delta") nameAddr = &sc->acqControlList[varIndex].deltaMacro; else if( type == "final" || type == "last" || type == "end" ) nameAddr = &sc->acqControlList[varIndex].finalMacro; if(nameAddr) { QString macro( "$(" + varName + ")"); if( *nameAddr) free(*nameAddr); *nameAddr = strdup(macro.toAscii().data() ); } }
void PathgridMode::dragCompleted(const QPoint& pos) { if (mDragMode == DragMode_Move) { std::vector<osg::ref_ptr<TagBase> > selection = getWorldspaceWidget().getSelection (Mask_Pathgrid); for (std::vector<osg::ref_ptr<TagBase> >::iterator it = selection.begin(); it != selection.end(); ++it) { if (PathgridTag* tag = dynamic_cast<PathgridTag*>(it->get())) { QUndoStack& undoStack = getWorldspaceWidget().getDocument().getUndoStack(); QString description = "Move pathgrid node(s)"; CSMWorld::CommandMacro macro(undoStack, description); tag->getPathgrid()->applyPosition(macro); } } } else if (mDragMode == DragMode_Edge) { WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask()); if (hit.tag) { if (PathgridTag* tag = dynamic_cast<PathgridTag*>(hit.tag.get())) { if (tag->getPathgrid()->getId() == mEdgeId) { unsigned short toNode = SceneUtil::getPathgridNode(static_cast<unsigned short>(hit.index0)); QUndoStack& undoStack = getWorldspaceWidget().getDocument().getUndoStack(); QString description = "Add edge between nodes"; CSMWorld::CommandMacro macro(undoStack, description); tag->getPathgrid()->applyEdge(macro, mFromNode, toNode); } } } mEdgeId.clear(); mFromNode = 0; } mDragMode = DragMode_None; getWorldspaceWidget().reset(Mask_Pathgrid); }
void pmultuw() { #define macro(_idx) \ mov32_eax_mem(_GPR_D(_rs, _idx)); \ mul_mem(_GPR_D(_rt, _idx)); \ mov32_reg_reg(_ecx, _edx); \ cdq(); \ mov32_mem_reg((u32)&g_cpu->m_lo.d[_idx], _eax); \ mov32_mem_reg((u32)&g_cpu->m_lo.d[_idx + 1], _edx); \ if (_rd) mov32_mem_reg(_GPR_D(_rd, _idx), _eax); \ mov32_reg_reg(_eax, _ecx); \ cdq(); \ mov32_mem_reg((u32)&g_cpu->m_hi.d[_idx], _eax); \ mov32_mem_reg((u32)&g_cpu->m_hi.d[_idx + 1], _edx); \ if (_rd) mov32_mem_reg(_GPR_D(_rd, _idx + 1), _eax); macro(0); // 63-0 macro(2); // 127-64 #undef macro }
void CSVWorld::NestedTable::removeRowActionTriggered() { CSMWorld::CommandMacro macro(mDocument.getUndoStack(), selectionModel()->selectedRows().size() > 1 ? tr("Remove rows") : ""); // Remove rows in reverse order for (int i = selectionModel()->selectedRows().size() - 1; i >= 0; --i) { macro.push(new CSMWorld::DeleteNestedCommand(*(mModel->model()), mModel->getParentId(), selectionModel()->selectedRows()[i].row(), mModel->getParentColumn())); } }
QVector<rpp::pp_macro*> computeGccStandardMacros(bool withStdCpp0x = true) { QVector<rpp::pp_macro*> ret; //Get standard macros from gcc KProcess proc; proc.setOutputChannelMode(KProcess::MergedChannels); // The output of the following gcc commands is several line in the format: // "#define MACRO [definition]", where definition may or may not be present. // Parsing each line sequentially, we can easily build the macro set. proc << "gcc"; if (withStdCpp0x) { // see also: https://bugs.kde.org/show_bug.cgi?id=298252 proc << "-std=c++0x"; } proc << "-xc++" << "-E" << "-dM" <<NULL_DEVICE; if (proc.execute(5000) == 0) { QString line; while (proc.canReadLine()) { QByteArray buff = proc.readLine(); if (!buff.isEmpty()) { line = buff; if (line.startsWith("#define ")) { line = line.right(line.length() - 8).trimmed(); int pos = line.indexOf(' '); ret.append(new rpp::pp_macro); rpp::pp_macro& macro(*ret.back()); if (pos != -1) { macro.name = IndexedString( line.left(pos) ); macro.setDefinitionText( line.right(line.length() - pos - 1).toUtf8() ); } else { macro.name = IndexedString( line ); } } } } } else if (withStdCpp0x) { // fallback to macro computation without -std=c++0x arg for old gcc versions return computeGccStandardMacros(false); } else { kDebug(9007) <<"Unable to read standard c++ macro definitions from gcc:" <<QString(proc.readAll()) ; } return ret; }
void LTRTextBuilder::updateLTR_TokenFromVertex( const LinguisticGraphVertex& vertex, const LinguisticGraph& graph, LTR_Token* tokenRep, uint64_t offset) const { // get data from the result of the linguistic analysis Token* fullToken = get(vertex_token, graph, vertex); MorphoSyntacticData* data = get(vertex_data, graph, vertex); const FsaStringsPool& sp = (Common::MediaticData::MediaticData::single().stringsPool(m_language)); sort(data->begin(),data->end(),ltNormProperty(m_macroAccessor)); StringsPoolIndex norm(0),lastNorm(0); LinguisticCode macro(0),lastMacro(0); for (MorphoSyntacticData::const_iterator elemItr=data->begin(); elemItr!=data->end(); elemItr++) { norm = elemItr->normalizedForm; macro = m_macroAccessor->readValue(elemItr->properties); if (norm == lastNorm && macro == lastMacro) { continue; } else { lastNorm=norm; lastMacro=macro; LimaString normStr= sp[norm]; // test if the same word was not already met at this position bool selectionFlag = true; LTR_Token::const_iterator itTok = tokenRep->begin(); while (selectionFlag && (itTok != tokenRep->end())) { selectionFlag = (itTok->first->getLemma() != normStr) || (itTok->first->getCategory() != macro); itTok ++; } if (selectionFlag) { // test if the current token is a plain word bool plainWordFlag = this->isWordToSelect(normStr, macro,m_microAccessor->readValue(elemItr->properties)); BoWToken* bowToken = new BoWToken(normStr,macro, fullToken->position() + offset, fullToken->length()); bowToken->setInflectedForm(fullToken->stringForm()); tokenRep->push_back(make_pair(bowToken, plainWordFlag)); } } } }
branch() { register char c; register int i; extern char getch(); # ifdef xMTR2 if (tTf(16, -1)) printf(">>branch: "); # endif /* see if conditional */ while ((c = getch()) > 0) if (c != ' ' && c != '\t') break; if (c == '?') { /* got a conditional; evaluate it */ Oneline = TRUE; macinit(&getch, 0, 0); i = expr(); if (i <= 0) { /* no branch */ # ifdef xMTR2 if (tTf(16, 0)) printf("no branch\n"); # endif getfilename(); return; } } else { Peekch = c; } /* get the target label */ if (branchto(getfilename()) == 0) if (branchto(macro("{default}")) == 0) { Peekch = -1; printf("Cannot branch\n"); } return; }
void PathgridMode::primaryEditPressed(const WorldspaceHitResult& hitResult) { if (CSMPrefs::get()["3D Scene Input"]["context-select"].isTrue() && dynamic_cast<PathgridTag*>(hitResult.tag.get())) { primarySelectPressed(hitResult); } else if (Cell* cell = getWorldspaceWidget().getCell (hitResult.worldPos)) { // Add node QUndoStack& undoStack = getWorldspaceWidget().getDocument().getUndoStack(); QString description = "Add node"; CSMWorld::CommandMacro macro(undoStack, description); cell->getPathgrid()->applyPoint(macro, hitResult.worldPos); } }
extern QList<QSharedPointer<Macro> > loadFromFile(const QString &fileName) { QList<QSharedPointer<Macro> > result; QFile f(fileName); if (f.open(QIODevice::ReadOnly|QIODevice::Text)) { QDomDocument doc; doc.setContent(&f); const QDomNodeList macros = doc.elementsByTagName("macro"); for (int i=0; i<macros.count(); i++) { QSharedPointer<Macro> macro(new Macro()); if (loadMacro(macros.at(i).toElement(), macro)) { result << macro; } } f.close(); } return result; }
static void changed_cb(GtkComboBox *combo, gpointer user_data) { RyostklconfigProDimnessSelector *dimness_selector = RYOSTKLCONFIG_PRO_DIMNESS_SELECTOR(combo); RyostklconfigProDimnessSelectorPrivate *priv = dimness_selector->priv; guint type; type = get_active_type(dimness_selector); switch (type) { case RYOS_LIGHT_DIMNESS_TYPE_MACRO: type = macro(dimness_selector); break; default: break; } priv->dimness_type = type; update(dimness_selector); }
void PathgridMode::secondaryEditPressed(const WorldspaceHitResult& hit) { if (hit.tag) { if (PathgridTag* tag = dynamic_cast<PathgridTag*>(hit.tag.get())) { if (tag->getPathgrid()->isSelected()) { unsigned short node = SceneUtil::getPathgridNode(static_cast<unsigned short>(hit.index0)); QUndoStack& undoStack = getWorldspaceWidget().getDocument().getUndoStack(); QString description = "Connect node to selected nodes"; CSMWorld::CommandMacro macro(undoStack, description); tag->getPathgrid()->applyEdges(macro, node); } } } }
shell() { register int i; register char *p; register char *shellfile; char *getfilename(); char *macro(); shellfile = getfilename(); if (*shellfile == 0) shellfile = 0; fclose(Qryiop); if ((Xwaitpid = fork()) == -1) syserr("shell: fork"); if (Xwaitpid == 0) { setuid(getuid()); # ifndef xB_UNIX setgid(getgid()); # endif for (i = 3; i < MAXFILES; i++) close(i); p = macro("{shell}"); # ifdef xMTR3 tTfp(7, 0, "{shell} = '%o'\n", p); # endif if (p != 0) { execl(p, p, shellfile, Qbname, 0); printf("Cannot call %s; using /bin/sh\n", p); } execl("/bin/sh", "sh", shellfile, Qbname, 0); syserr("shell: exec"); } if (Nodayfile >= 0) printf(">>shell\n"); /* wait for shell to complete */ xwait(); }
// Write out the config file for the whole application int configAppSaveXml() { if (bCmdOptUsed) { return 1; } char configName[MAX_PATH]; createConfigName(configName); try { char tempStr[64] = ""; // root ticpp::Document doc; ticpp::Declaration decl("1.0", "UTF-8", ""); doc.LinkEndChild(&decl); ticpp::Element root("configuration"); setAttr(root, "version", configVersion); ticpp::Comment comment("Don't edit this file manually unless you know what you're doing\n" \ APP_TITLE " will restore default settings when this file is deleted"); doc.LinkEndChild(&comment); doc.LinkEndChild(&root); // title sprintf(tempStr, "0x%06X", nBurnVer); addTextNode(root, "version", tempStr); // emulation ticpp::Element emulation("emulation"); root.LinkEndChild(&emulation); setAttr(emulation, "asm-68k", bBurnUseASM68K); setAttr(emulation, "all-ram", bDrvSaveAll); // video ticpp::Element video("video"); root.LinkEndChild(&video); ticpp::Element fullscreen("fullscreen"); video.LinkEndChild(&fullscreen); setAttr(fullscreen, "width", nVidWidth); setAttr(fullscreen, "height", nVidHeight); setAttr(fullscreen, "depth", nVidDepth); setAttr(fullscreen, "refresh", nVidRefresh); ticpp::Element adjust("adjust"); video.LinkEndChild(&adjust); setAttr(adjust, "rotate-vertical", nVidRotationAdjust); ticpp::Element screen_size("screen-size"); video.LinkEndChild(&screen_size); setAttr(screen_size, "window", nWindowSize); ticpp::Element window_position("window-position"); video.LinkEndChild(&window_position); setAttr(window_position, "x", nWindowPosX); setAttr(window_position, "y", nWindowPosY); ticpp::Element stretch("stretch"); video.LinkEndChild(&stretch); setAttr(stretch, "full-stretch", bVidFullStretch); setAttr(stretch, "correct-aspect", bVidCorrectAspect); ticpp::Element color("color"); video.LinkEndChild(&color); setAttr(color, "enable", bcolorAdjust); setAttr(color, "contrast", color_contrast); setAttr(color, "brightness", color_brightness); setAttr(color, "gamma", color_gamma); setAttr(color, "grayscale", color_grayscale); setAttr(color, "invert", color_invert); ticpp::Element vsync("vsync"); video.LinkEndChild(&vsync); setAttr(vsync, "enable", bVidVSync); ticpp::Element triple_buffer("triple-buffer"); video.LinkEndChild(&triple_buffer); setAttr(triple_buffer, "enable", bVidTripleBuffer); // video render ticpp::Element render("render"); video.LinkEndChild(&render); ticpp::Element render_driver("render-driver"); render.LinkEndChild(&render_driver); setAttr(render_driver, "driver", nVidSelect); setAttr(render_driver, "adapter", nVidAdapter); ticpp::Element filter("filter"); render.LinkEndChild(&filter); setAttr(filter, "linear", vidFilterLinear); setAttr(filter, "use-pixelfilter", vidUseFilter); setAttr(filter, "pixel-filter", nVidFilter); ticpp::Element option("option"); render.LinkEndChild(&option); setAttr(option, "force-16bit", bVidForce16bit); setAttr(option, "hardware-vertex", vidHardwareVertex); setAttr(option, "motion-blur", vidMotionBlur); setAttr(option, "projection", nVid3DProjection); setAttr(option, "angel", fVidScreenAngle); setAttr(option, "curvature", fVidScreenCurvature); setAttr(option, "dxmanager", nVidDXTextureManager); setAttr(option, "x-offset", nXOffset); setAttr(option, "y-offset", nYOffset); setAttr(option, "x-scale", nXScale); setAttr(option, "y-scale", nYScale); // video others ticpp::Element monitor("monitor"); video.LinkEndChild(&monitor); setAttr(monitor, "auto-aspect", autoVidScrnAspect); setAttr(monitor, "aspect-x", nVidScrnAspectX); setAttr(monitor, "aspect-y", nVidScrnAspectY); ticpp::Element frame("frame"); video.LinkEndChild(&frame); setAttr(frame, "auto-frameskip", autoFrameSkip); setAttr(frame, "force-60hz", bForce60Hz); // audio ticpp::Element audio("audio"); root.LinkEndChild(&audio); addTextNode(audio, "sound", audSelect); ticpp::Element device("device"); audio.LinkEndChild(&device); setAttr(device, "ds", dsDevice); setAttr(device, "xa2", xa2Device); setAttr(device, "oal", oalDevice); ticpp::Element audio_set("setting"); audio.LinkEndChild(&audio_set); setAttr(audio_set, "rate", nAudSampleRate); setAttr(audio_set, "frame", nAudSegCount); setAttr(audio_set, "dsp", nAudDSPModule); setAttr(audio_set, "pcm-interp", nInterpolation); setAttr(audio_set, "fm-interp", nFMInterpolation); setAttr(audio_set, "stereo-upmix", audStereoUpmixing); // gui ticpp::Element gui("gui"); root.LinkEndChild(&gui); addTextNode(gui, "language", szLanguage); //addTextNode(gui, "gamelist", szTransGamelistFile); ticpp::Element chat("chat-font"); gui.LinkEndChild(&chat); setAttr(chat, "min-size", nMinChatFontSize); setAttr(chat, "max-size", nMaxChatFontSize); ticpp::Element menu("menu"); gui.LinkEndChild(&menu); setAttr(menu, "modeless", bModelessMenu); setAttr(menu, "style", menuNewStyle); ticpp::Element gui_misc("gui-misc"); gui.LinkEndChild(&gui_misc); setAttr(gui_misc, "on-top", bShowOnTop); setAttr(gui_misc, "auto-fullscreen", bFullscreenOnStart); setAttr(gui_misc, "lastRom", nLastRom); setAttr(gui_misc, "lastFilter", nLastFilter); setAttr(gui_misc, "hideChildren", HideChildren); setAttr(gui_misc, "showThreeFourPlayerOnly", ThreeOrFourPlayerOnly); setAttr(gui_misc, "arcadeJoyStickSettings", ArcadeJoystick); // gui load game dialog ticpp::Element gamelist("gamelist-dlg"); gui.LinkEndChild(&gamelist); setAttr(gamelist, "options", nLoadMenuShowX); //setAttr(gamelist, "drivers", nLoadDriverShowX); //setAttr(gamelist, "sys-sel", nSystemSel); //setAttr(gamelist, "tab-sel", nTabSel); //addTextNode(gamelist, "user-filter", szUserFilterStr); // gui ips ticpp::Element ips("ips"); gui.LinkEndChild(&ips); setAttr(ips, "language", nPatchLang); setAttr(ips, "dependancy", bEnforceDep); //ticpp::Element skin("skin"); //gui.LinkEndChild(&skin); //setAttr(skin, "use-placeholder", bVidUsePlaceholder); //setAttr(skin, "random", nRandomSkin); //addTextNode(skin, NULL, szPlaceHolder); // preferences ticpp::Element preference("preferences"); root.LinkEndChild(&preference); ticpp::Element settings("settings"); preference.LinkEndChild(&settings); setAttr(settings, "always-processkey", bAlwaysProcessKey); setAttr(settings, "auto-pause", bAutoPause); //setAttr(settings, "avi-audio", nAviIntAudio); //setAttr(settings, "use-gdip", bUseGdip); ticpp::Element fastforward("fastforward"); preference.LinkEndChild(&fastforward); setAttr(fastforward, "speed", nFastSpeed); ticpp::Element thread("thread"); preference.LinkEndChild(&thread); setAttr(thread, "priority", nAppThreadPriority); ticpp::Element autofire("autofire"); preference.LinkEndChild(&autofire); setAttr(autofire, "enable", nAutofireEnabled); setAttr(autofire, "default-delay", autofireDefaultDelay); ticpp::Element macro("macro"); preference.LinkEndChild(¯o); setAttr(macro, "enable", nInputMacroEnabled); // pref misc ticpp::Element pref_misc("misc"); preference.LinkEndChild(&pref_misc); setAttr(pref_misc, "effect", nShowEffect); ticpp::Element controls("controls"); preference.LinkEndChild(&controls); for (int i = 0; i < 4; i++) { sprintf(tempStr, "default%d", i); addTextNode(controls, tempStr, szPlayerDefaultIni[i]); } // paths ticpp::Element paths("paths"); root.LinkEndChild(&paths); ticpp::Element rom_path("rom"); paths.LinkEndChild(&rom_path); for (int i = 0; i < DIRS_MAX; i++) { addTextNode(rom_path, "path", szAppRomPaths[i]); } ticpp::Element misc_path("misc"); paths.LinkEndChild(&misc_path); for (int i = PATH_PREVIEW; i < PATH_SUM; i++) { sprintf(tempStr, "path%d", i); addTextNode(misc_path, tempStr, szMiscPaths[i]); } // hotkeys ticpp::Element hotkeys("hotkeys"); root.LinkEndChild(&hotkeys); /*for (int i = 0; !lastCustomKey(customKeys[i]); i++) { CustomKey& customkey = customKeys[i]; ticpp::Element key(customkey.config_code); hotkeys.LinkEndChild(&key); setAttr(key, "key", customkey.key); setAttr(key, "mod", customkey.keymod); }*/ // save file doc.SaveFile(configName, TIXML_ENCODING_UTF8); } catch (ticpp::Exception& ex) { return 1; } return 0; }
bool Bass::executeInstruction(Instruction& i) { activeInstruction = &i; string s = i.statement; evaluateDefines(s); if(s.match("macro ?*(*) {") || s.match("global macro ?*(*) {")) { bool local = s.beginsWith("global ") == false; s.ltrim<1>("global "); s.trim<1>("macro ", ") {"); lstring p = s.split<1>("("); bool scoped = p(0).beginsWith("scope "); p(0).ltrim<1>("scope "); lstring a = p(1).empty() ? lstring{} : p(1).qsplit(",").strip(); setMacro(p(0), a, ip, scoped, local); ip = i.ip; return true; } if(s.match("define ?*(*)") || s.match("global define ?*(*)")) { bool local = s.beginsWith("global ") == false; s.ltrim<1>("global "); lstring p = s.trim<1>("define ", ")").split<1>("("); setDefine(p(0), p(1), local); return true; } if(s.match("evaluate ?*(*)") || s.match("global evaluate ?*(*)")) { bool local = s.beginsWith("global ") == false; s.ltrim<1>("global "); lstring p = s.trim<1>("evaluate ", ")").split<1>("("); setDefine(p(0), evaluate(p(1)), local); return true; } if(s.match("variable ?*(*)") || s.match("global variable ?*(*)")) { bool local = s.beginsWith("global ") == false; s.ltrim<1>("global "); lstring p = s.trim<1>("variable ", ")").split<1>("("); setVariable(p(0), evaluate(p(1)), local); return true; } if(s.match("if ?* {")) { s.trim<1>("if ", " {").strip(); bool match = evaluate(s, Evaluation::Strict); ifStack.append(match); if(match == false) { ip = i.ip; } return true; } if(s.match("} else if ?* {")) { if(ifStack.last()) { ip = i.ip; } else { s.trim<1>("} else if ", " {").strip(); bool match = evaluate(s, Evaluation::Strict); ifStack.last() = match; if(match == false) { ip = i.ip; } } return true; } if(s.match("} else {")) { if(ifStack.last()) { ip = i.ip; } else { ifStack.last() = true; } return true; } if(s.match("} endif")) { ifStack.removeLast(); return true; } if(s.match("while ?* {")) { s.trim<1>("while ", " {").strip(); bool match = evaluate(s, Evaluation::Strict); if(match == false) ip = i.ip; return true; } if(s.match("} endwhile")) { ip = i.ip; return true; } if(s.match("?*(*)")) { lstring p = string{s}.rtrim<1>(")").split<1>("("); lstring a = p(1).empty() ? lstring{} : p(1).qsplit(",").strip(); string name = {p(0), ":", a.size()}; //arity overloading if(auto macro = findMacro({name})) { struct Parameter { enum class Type : unsigned { Define, Variable } type; string name; string value; }; vector<Parameter> parameters; for(unsigned n = 0; n < a.size(); n++) { lstring p = macro().parameters(n).split<1>(" ").strip(); if(p.size() == 1) p.prepend("define"); if(p(0) == "define") parameters.append({Parameter::Type::Define, p(1), a(n)}); else if(p(0) == "string") parameters.append({Parameter::Type::Define, p(1), text(a(n))}); else if(p(0) == "evaluate") parameters.append({Parameter::Type::Define, p(1), evaluate(a(n))}); else if(p(0) == "variable") parameters.append({Parameter::Type::Variable, p(1), evaluate(a(n))}); else error("unsupported parameter type: ", p(0)); } StackFrame frame; stackFrame.append(frame); stackFrame.last().ip = ip; stackFrame.last().scoped = macro().scoped; if(macro().scoped) { scope.append(p(0)); } setDefine("#", {"_", macroInvocationCounter++}, true); for(auto& parameter : parameters) { if(parameter.type == Parameter::Type::Define) setDefine(parameter.name, parameter.value, true); if(parameter.type == Parameter::Type::Variable) setVariable(parameter.name, integer(parameter.value), true); } ip = macro().ip; return true; } } if(s.match("} endmacro")) { ip = stackFrame.last().ip; if(stackFrame.last().scoped) scope.removeLast(); stackFrame.removeLast(); return true; } if(assemble(s)) { return true; } evaluate(s); return true; }
void comline(void) { long c1, c2; while(C==' ' || c=='\t') ; comx: if((c1=c) == '\n') return; c2 = C; if(c1=='.' && c2!='.') inmacro = NO; if(msflag && c1 == '['){ refer(c2); return; } if(c2 == '\n') return; if(c1 == '\\' && c2 == '\"') SKIP; else if (filesp==files && c1=='E' && c2=='Q') eqn(); else if(filesp==files && c1=='T' && (c2=='S' || c2=='C' || c2=='&')) { if(msflag) stbl(); else tbl(); } else if(c1=='T' && c2=='E') intable = NO; else if (!inmacro && ((c1 == 'd' && c2 == 'e') || (c1 == 'i' && c2 == 'g') || (c1 == 'a' && c2 == 'm'))) macro(); else if(c1=='s' && c2=='o') { if(iflag) SKIP; else { getfname(); if(fname[0]) { if(infile = opn(fname)) *++filesp = infile; else infile = *filesp; } } } else if(c1=='n' && c2=='x') if(iflag) SKIP; else { getfname(); if(fname[0] == '\0') exits(0); if(Bfildes(&(infile->Biobufhdr)) != 0) Bterm(&(infile->Biobufhdr)); infile = *filesp = opn(fname); } else if(c1 == 't' && c2 == 'm') SKIP; else if(c1=='h' && c2=='w') SKIP; else if(msflag && c1 == 'T' && c2 == 'L') { SKIP_TO_COM; goto comx; } else if(msflag && c1=='N' && c2 == 'R') SKIP; else if(msflag && c1 == 'A' && (c2 == 'U' || c2 == 'I')){ if(mac==MM)SKIP; else { SKIP_TO_COM; goto comx; } } else if(msflag && c1=='F' && c2=='S') { SKIP_TO_COM; goto comx; } else if(msflag && (c1=='S' || c1=='N') && c2=='H') { SKIP_TO_COM; goto comx; } else if(c1 == 'U' && c2 == 'X') { if(wordflag) Bprint(&(bout.Biobufhdr), "UNIX\n"); else Bprint(&(bout.Biobufhdr), "UNIX "); } else if(msflag && c1=='O' && c2=='K') { SKIP_TO_COM; goto comx; } else if(msflag && c1=='N' && c2=='D') SKIP; else if(msflag && mac==MM && c1=='H' && (c2==' '||c2=='U')) SKIP; else if(msflag && mac==MM && c2=='L') { if(disp || c1=='R') sdis('L', 'E'); else { SKIP; Bprint(&(bout.Biobufhdr), " ."); } } else if(!msflag && c1=='P' && c2=='S') { inpic(); } else if(msflag && (c1=='D' || c1=='N' || c1=='K'|| c1=='P') && c2=='S') { sdis(c1, 'E'); } else if(msflag && (c1 == 'K' && c2 == 'F')) { sdis(c1,'E'); } else if(msflag && c1=='n' && c2=='f') sdis('f','i'); else if(msflag && c1=='c' && c2=='e') sce(); else { if(c1=='.' && c2=='.') { if(msflag) { SKIP; return; } while(C == '.') ; } inmacro++; if(c1 <= 'Z' && msflag) regline(YES,ONE); else { if(wordflag) C; regline(YES,TWO); } inmacro--; } }
int main(int argc, char *argv[]) { int c; int n; int rval; char *p; setlocale(LC_ALL, ""); traceout = stderr; if (signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, onintr); initkwds(); initspaces(); STACKMAX = INITSTACKMAX; mstack = (stae *)xalloc(sizeof(stae) * STACKMAX); sstack = (char *)xalloc(STACKMAX); maxout = 0; outfile = NULL; resizedivs(MAXOUT); while ((c = getopt(argc, argv, "gst:d:D:U:o:I:")) != -1) switch(c) { case 'D': /* define something..*/ for (p = optarg; *p; p++) if (*p == '=') break; if (p == optarg) errx(1, "null variable cannot be defined"); if (*p) *p++ = EOS; dodefine(optarg, p); break; case 'I': addtoincludepath(optarg); break; case 'U': /* undefine... */ remhash(optarg, TOP); break; case 'g': mimic_gnu = 1; break; case 'd': set_trace_flags(optarg); break; case 's': synccpp = 1; break; case 't': mark_traced(optarg, 1); break; case 'o': trace_file(optarg); break; case '?': default: usage(); } argc -= optind; argv += optind; rval = 0; active = stdout; /* default active output */ bbase[0] = bufbase; if (!argc) { sp = -1; /* stack pointer initialized */ fp = 0; /* frame pointer initialized */ set_input(infile+0, stdin, "stdin"); /* default input (naturally) */ if ((inname[0] = strdup("-")) == NULL) err(1, NULL); inlineno[0] = 1; emitline(); macro(); } else for (; argc--; ++argv) { p = *argv; if (p[0] == '-' && p[1] == EOS) set_input(infile, stdin, "stdin"); else if (fopen_trypath(infile, p) == NULL) { warn("%s", p); rval = 1; continue; } sp = -1; fp = 0; if ((inname[0] = strdup(p)) == NULL) err(1, NULL); inlineno[0] = 1; emitline(); macro(); release_input(infile); } if (*m4wraps) { /* anything for rundown ?? */ ilevel = 0; /* in case m4wrap includes.. */ bufbase = bp = buf; /* use the entire buffer */ pbstr(m4wraps); /* user-defined wrapup act */ macro(); /* last will and testament */ } if (active != stdout) active = stdout; /* reset output just in case */ for (n = 1; n < maxout; n++) /* default wrap-up: undivert */ if (outfile[n] != NULL) getdiv(n); /* remove bitbucket if used */ if (outfile[0] != NULL) { (void) fclose(outfile[0]); } exit(rval); }
static int scanpp(void) { int c, t; if (Rejected != -1) { t = Rejected; Rejected = -1; strcpy(Text, Rejtext); Value = Rejval; return t; } for (;;) { Value = 0; c = skip(); memset(Text, 0, 4); Text[0] = c; switch (c) { case '!': if ((c = next()) == '=') { Text[1] = '='; return NOTEQ; } else { putback(c); return XMARK; } case '%': if ((c = next()) == '=') { Text[1] = '='; return ASMOD; } else { putback(c); return MOD; } case '&': if ((c = next()) == '&') { Text[1] = '&'; return LOGAND; } else if ('=' == c) { Text[1] = '='; return ASAND; } else { putback(c); return AMPER; } case '(': return LPAREN; case ')': return RPAREN; case '*': if ((c = next()) == '=') { Text[1] = '='; return ASMUL; } else { putback(c); return STAR; } case '+': if ((c = next()) == '+') { Text[1] = '+'; return INCR; } else if ('=' == c) { Text[1] = '='; return ASPLUS; } else { putback(c); return PLUS; } case ',': return COMMA; case '-': if ((c = next()) == '-') { Text[1] = '-'; return DECR; } else if ('=' == c) { Text[1] = '='; return ASMINUS; } else if ('>' == c) { Text[1] = '>'; return ARROW; } else { putback(c); return MINUS; } case '/': if ((c = next()) == '=') { Text[1] = '='; return ASDIV; } else { putback(c); return SLASH; } case ':': return COLON; case ';': return SEMI; case '<': if ((c = next()) == '<') { Text[1] = '<'; if ((c = next()) == '=') { Text[2] = '='; return ASLSHIFT; } else { putback(c); return LSHIFT; } } else if ('=' == c) { Text[1] = '='; return LTEQ; } else { putback(c); return LESS; } case '=': if ((c = next()) == '=') { Text[1] = '='; return EQUAL; } else { putback(c); return ASSIGN; } case '>': if ((c = next()) == '>') { Text[1] = '>'; if ((c = next()) == '=') { Text[1] = '='; return ASRSHIFT; } else { putback(c); return RSHIFT; } } else if ('=' == c) { Text[1] = '='; return GTEQ; } else { putback(c); return GREATER; } case '?': return QMARK; case '[': return LBRACK; case ']': return RBRACK; case '^': if ((c = next()) == '=') { Text[1] = '='; return ASXOR; } else { putback(c); return CARET; } case '{': return LBRACE; case '|': if ((c = next()) == '|') { Text[1] = '|'; return LOGOR; } else if ('=' == c) { Text[1] = '='; return ASOR; } else { putback(c); return PIPE; } case '}': return RBRACE; case '~': return TILDE; case EOF: strcpy(Text, "<EOF>"); return XEOF; case '\'': Text[1] = Value = scanch(); if ((c = next()) != '\'') error( "expected '\\'' at end of char literal", NULL); Text[2] = '\''; return INTLIT; case '"': Value = scanstr(Text); return STRLIT; case '#': Text[0] = '#'; scanident(next(), &Text[1], TEXTLEN-1); if ((t = keyword(Text)) != 0) return t; error("unknown preprocessor command: %s", Text); return IDENT; case '.': if ((c = next()) == '.') { Text[1] = Text[2] = '.'; Text[3] = 0; if ((c = next()) == '.') return ELLIPSIS; putback(c); error("incomplete '...'", NULL); return ELLIPSIS; } putback(c); return DOT; default: if (isdigit(c)) { Value = scanint(c); return INTLIT; } else if (isalpha(c) || '_' == c) { Value = scanident(c, Text, TEXTLEN); if (Expandmac && macro(Text)) break; if ((t = keyword(Text)) != 0) return t; return IDENT; } else { cerror("funny input character: %s", c); break; } } } }
int main(int argc, char *argv[]) { int c; int n; char *p; if (signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, onintr); init_macros(); initspaces(); STACKMAX = INITSTACKMAX; mstack = xreallocarray(NULL, STACKMAX, sizeof(stae), NULL); sstack = xalloc(STACKMAX, NULL); maxout = 0; outfile = NULL; resizedivs(MAXOUT); while ((c = getopt(argc, argv, "gst:d:D:U:o:I:P")) != -1) switch(c) { case 'D': /* define something..*/ for (p = optarg; *p; p++) if (*p == '=') break; if (*p) *p++ = EOS; dodefine(optarg, p); break; case 'I': addtoincludepath(optarg); break; case 'P': prefix_builtins = 1; break; case 'U': /* undefine... */ macro_popdef(optarg); break; case 'g': mimic_gnu = 1; break; case 'd': set_trace_flags(optarg); break; case 's': synch_lines = 1; break; case 't': mark_traced(optarg, 1); break; case 'o': trace_file(optarg); break; case '?': usage(); } argc -= optind; argv += optind; initkwds(); if (mimic_gnu) setup_builtin("format", FORMATTYPE); active = stdout; /* default active output */ bbase[0] = bufbase; if (!argc) { sp = -1; /* stack pointer initialized */ fp = 0; /* frame pointer initialized */ set_input(infile+0, stdin, "stdin"); /* default input (naturally) */ macro(); } else for (; argc--; ++argv) { p = *argv; if (p[0] == '-' && p[1] == EOS) set_input(infile, stdin, "stdin"); else if (fopen_trypath(infile, p) == NULL) err(1, "%s", p); sp = -1; fp = 0; macro(); release_input(infile); } if (wrapindex) { int i; ilevel = 0; /* in case m4wrap includes.. */ bufbase = bp = buf; /* use the entire buffer */ if (mimic_gnu) { while (wrapindex != 0) { for (i = 0; i < wrapindex; i++) pbstr(m4wraps[i]); wrapindex =0; macro(); } } else { for (i = 0; i < wrapindex; i++) { pbstr(m4wraps[i]); macro(); } } } if (active != stdout) active = stdout; /* reset output just in case */ for (n = 1; n < maxout; n++) /* default wrap-up: undivert */ if (outfile[n] != NULL) getdiv(n); /* remove bitbucket if used */ if (outfile[0] != NULL) { (void) fclose(outfile[0]); } return exit_code; }
void eval(BOOLEAN do_gc) { static unsigned int count = 0; OBJECT_PTR exp = car(reg_next_expression); OBJECT_PTR opcode = car(exp); pin_globals(); if(do_gc) { count++; if(count == GC_FREQUENCY) { gc(false, true); count = 0; } } if(opcode == APPLY && profiling_in_progress) { last_operator = reg_accumulator; if(prev_operator != NIL) { OBJECT_PTR operator_to_be_used; hashtable_entry_t *e; unsigned int count; unsigned int mem_alloc; double elapsed_wall_time; double elapsed_cpu_time; double temp1 = get_wall_time(); clock_t temp2 = clock(); unsigned int temp3 = memory_allocated(); profiling_datum_t *pd = (profiling_datum_t *)malloc(sizeof(profiling_datum_t)); if(IS_SYMBOL_OBJECT(prev_operator)) operator_to_be_used = prev_operator; else { OBJECT_PTR res = get_symbol_from_value(prev_operator, reg_current_env); if(car(res) != NIL) operator_to_be_used = cdr(res); else operator_to_be_used = cons(LAMBDA, cons(get_params_object(prev_operator), cons(car(get_source_object(prev_operator)), NIL))); } e = hashtable_get(profiling_tab, (void *)operator_to_be_used); if(e) { profiling_datum_t *pd = (profiling_datum_t *)e->value; count = pd->count + 1; elapsed_wall_time = pd->elapsed_wall_time + temp1 - wall_time_var; elapsed_cpu_time = pd->elapsed_cpu_time + (temp2 - cpu_time_var) * 1.0 / CLOCKS_PER_SEC; mem_alloc = pd->mem_allocated + temp3 - mem_alloc_var; hashtable_remove(profiling_tab, (void *)operator_to_be_used); free(pd); } else { count = 1; elapsed_wall_time = temp1 - wall_time_var; elapsed_cpu_time = (temp2 - cpu_time_var) * 1.0 / CLOCKS_PER_SEC; mem_alloc = temp3 - mem_alloc_var; } pd->count = count; pd->elapsed_wall_time = elapsed_wall_time; pd->elapsed_cpu_time = elapsed_cpu_time; pd->mem_allocated = mem_alloc; hashtable_put(profiling_tab, (void *)operator_to_be_used, (void *)pd); } wall_time_var = get_wall_time(); cpu_time_var = clock(); mem_alloc_var = memory_allocated(); prev_operator = reg_accumulator; } if(opcode == HALT) { halt_op(); } else if(opcode == REFER) { if(refer(CADR(exp))) return; reg_next_expression = CADDR(exp); } else if(opcode == CONSTANT) { if(constant(CADR(exp))) return; reg_next_expression = CADDR(exp); } else if(opcode == CLOSE) { if(closure(exp)) return; reg_next_expression = fifth(exp); } else if(opcode == MACRO) { if(macro(exp)) return; reg_next_expression = CADDDDR(exp); } else if(opcode == TEST) { if(reg_accumulator != NIL) reg_next_expression = CADR(exp); else reg_next_expression = CADDR(exp); } //Not using this WHILE; reverting //to macro definition, as this //version doesn't handle (BREAK) else if(opcode == WHILE) { OBJECT_PTR cond = CADR(exp); OBJECT_PTR body = CADDR(exp); OBJECT_PTR ret = NIL; while(1) { OBJECT_PTR temp = reg_current_stack; reg_next_expression = cond; while(car(reg_next_expression) != NIL) { eval(false); if(in_error) return; } if(reg_accumulator == NIL) break; reg_next_expression = body; while(car(reg_next_expression) != NIL) { eval(false); if(in_error) return; } //to handle premature exits //via RETURN-FROM if(reg_current_stack != temp) return; ret = reg_accumulator; } reg_accumulator = ret; reg_next_expression = CADDDR(exp); } else if(opcode == ASSIGN) { if(assign(CADR(exp))) return; reg_next_expression = CADDR(exp); } else if(opcode == DEFINE) { if(define(CADR(exp))) return; reg_next_expression = CADDR(exp); } else if(opcode == CONTI) { if(conti()) return; reg_next_expression = CADR(exp); } else if(opcode == NUATE) //this never gets called { reg_current_stack = CADR(exp); reg_accumulator = CADDR(exp); reg_current_value_rib = NIL; reg_next_expression = cons(CONS_RETURN_NIL, cdr(reg_next_expression)); } else if(opcode == FRAME) { if(frame(exp)) return; reg_next_expression = CADDR(exp); } else if(opcode == ARGUMENT) { if(argument()) return; reg_next_expression = CADR(exp); } else if(opcode == APPLY) { apply_compiled(); } else if(opcode == RETURN) { return_op(); } }
void dParserCompiler::GenerateParserCode ( const dString& className, const dString& scannerClassName, const char* const outputFileName, const dTree<dTokenInfo, dCRCTYPE>& symbolList, dTree<dState*, dCRCTYPE>& stateList, const dString& userCode, const dString& endUserCode, int lastTerminalTokenEnum) { dString templateHeader (""); LoadTemplateFile("dParserTemplate _cpp.txt", templateHeader); int position = templateHeader.Find ("$(userCode)"); templateHeader.Replace(position, 11, userCode); ReplaceAllMacros (templateHeader, className, "$(className)"); ReplaceAllMacros (templateHeader, scannerClassName, "$(scannerClass)"); char text[256]; sprintf (text, "%d", lastTerminalTokenEnum); ReplaceMacro (templateHeader, text, "&(lastTerminalToken)"); dTree<dState*, dCRCTYPE> sortedStates; dTree<dState*, dCRCTYPE>::Iterator stateIter (stateList); for (stateIter.Begin(); stateIter; stateIter ++) { dState* const state = stateIter.GetNode()->GetInfo(); sortedStates.Insert(state, state->m_number); } dTree<int, dString> actionFilter; dString emptySematicAction (""); dString stateActionsStart (""); dString stateActionsCount (""); dString nextActionsStateList (""); dString sematicActions (""); int entriesCount = 0; int newLineCount = 0; int starAndCountIndex = 0; dTree<dState*, dCRCTYPE>::Iterator sortStateIter (sortedStates); const char* const caseTabs0 = "\t\t\t\t\t\t"; //const char* const caseTabs1 = "\t\t\t\t\t\t\t"; for (sortStateIter.Begin(); sortStateIter; sortStateIter ++) { dState* const state = sortStateIter.GetNode()->GetInfo(); int count = 0; dTree<dActionEntry, int> actionSort; dTree<dAction, dCRCTYPE>::Iterator actionIter (state->m_actions); for (actionIter.Begin(); actionIter; actionIter++) { count ++; dAction& action = actionIter.GetNode()->GetInfo(); if (action.m_type == dSHIFT) { dCRCTYPE actionSymbol = actionIter.GetKey(); dAssert (symbolList.Find(actionSymbol)); dActionEntry entry; entry.m_stateType = char (action.m_type); entry.m_errorRule = state->m_hasErroItem ? 1 : 0; entry.m_ruleIndex = 0; entry.m_ruleSymbols = 0; entry.m_nextState = short (action.m_nextState); entry.m_token = short (symbolList.Find(actionSymbol)->GetInfo().m_tokenId); actionSort.Insert (entry, entry.m_token); } else if (action.m_type == dREDUCE) { dCRCTYPE actionSymbol = actionIter.GetKey(); dAssert (symbolList.Find(actionSymbol)); dRuleInfo& reduceRule = action.m_reduceRuleNode->GetInfo(); dAssert (symbolList.Find(reduceRule.m_nameCRC)); dAssert (symbolList.Find(reduceRule.m_nameCRC)->GetInfo().m_tokenId >= 256); dActionEntry entry; entry.m_stateType = char (action.m_type); entry.m_errorRule = 0; //state->m_hasErroItem ? 1 : 0; entry.m_ruleIndex = short (reduceRule.m_ruleNumber); entry.m_ruleSymbols = short (reduceRule.GetCount()); entry.m_nextState = short (symbolList.Find(reduceRule.m_nameCRC)->GetInfo().m_tokenId - lastTerminalTokenEnum); entry.m_token = short (symbolList.Find(actionSymbol)->GetInfo().m_tokenId); actionSort.Insert (entry, entry.m_token); if (!reduceRule.m_ruleReduced && (reduceRule.m_semanticActionCode != emptySematicAction)) { // issue a sematic action code; reduceRule.m_ruleReduced = true; char text[128]; dString userSematicAction (reduceRule.m_semanticActionCode); int symbolsCount = int (entry.m_ruleSymbols); for (int i = 0; i < symbolsCount; i ++) { sprintf (text, "%d", symbolsCount - i); dString macro ("$"); macro += text; sprintf (text, "%d", symbolsCount - i - 1); dString macroVariable ("parameter["); macroVariable += text; macroVariable += "].m_value"; ReplaceAllMacros (userSematicAction, macroVariable, macro); } ReplaceAllMacros (userSematicAction, "entry.m_value", "$$"); sprintf (text, "%d:", reduceRule.m_ruleNumber); sematicActions += caseTabs0; sematicActions += "case "; sematicActions += text; //sematicActions += "// rule "; sematicActions += "// "; sematicActions += reduceRule.m_name; sematicActions += " : "; for (dRuleInfo::dListNode* node = reduceRule.GetFirst(); node; node = node->GetNext()) { sematicActions+= node->GetInfo().m_name; sematicActions += " "; } sematicActions += "\n"; sematicActions += userSematicAction; sematicActions += "\nbreak;\n\n"; } } else { dAssert (action.m_type == dACCEPT); dActionEntry entry; entry.m_stateType = char (action.m_type); entry.m_errorRule = 0; //state->m_hasErroItem ? 1 : 0; entry.m_ruleIndex = 0; entry.m_ruleSymbols = 0; entry.m_nextState = 0; entry.m_token = DACCEPTING_TOKEN; actionSort.Insert (entry, entry.m_token); } } int actionIndex = entriesCount; dString stateActions (""); dTree<dActionEntry, int>::Iterator iter (actionSort); for (iter.Begin(); iter; iter ++) { const dActionEntry& entry = iter.GetNode()->GetInfo(); sprintf (text, "%d, %d, %d, %d, %d, %d, ", entry.m_token, entry.m_errorRule, entry.m_stateType, entry.m_nextState, entry.m_ruleSymbols, entry.m_ruleIndex); stateActions += text; entriesCount ++; } dTree<int, dString>::dTreeNode* const stateActionNode = actionFilter.Find(stateActions); if (stateActionNode) { entriesCount = actionIndex; actionIndex = stateActionNode->GetInfo(); } else { actionFilter.Insert(actionIndex, stateActions); for (iter.Begin(); iter; iter ++) { if (newLineCount % 4 == 0) { nextActionsStateList += "\n\t\t\t"; } newLineCount ++; const dActionEntry& entry = iter.GetNode()->GetInfo(); sprintf (text, "dActionEntry (%d, %d, %d, %d, %d, %d), ", entry.m_token, entry.m_errorRule, entry.m_stateType, entry.m_nextState, entry.m_ruleSymbols, entry.m_ruleIndex); nextActionsStateList += text; } } if ((starAndCountIndex % 24) == 0) { stateActionsStart += "\n\t\t\t"; stateActionsCount += "\n\t\t\t"; } starAndCountIndex ++; sprintf (text, "%d, ", actionIndex); stateActionsStart += text; sprintf (text, "%d, ", count); stateActionsCount += text; } nextActionsStateList.Replace(nextActionsStateList.Size()-2, 2, ""); stateActionsCount.Replace(stateActionsCount.Size()-2, 2, ""); stateActionsStart.Replace(stateActionsStart.Size()-2, 2, ""); ReplaceMacro (templateHeader, stateActionsCount, "$(actionsCount)"); ReplaceMacro (templateHeader, stateActionsStart, "$(actionsStart)"); ReplaceMacro (templateHeader, nextActionsStateList, "$(actionTable)"); ReplaceMacro (templateHeader, sematicActions, "$(semanticActionsCode)"); dString stateGotoStart (""); dString stateGotoCount (""); dString nextGotoStateList (""); entriesCount = 0; int newLine = 0; int gotoStateCount = 0; for (sortStateIter.Begin(); sortStateIter; sortStateIter ++) { char text[256]; dState* const state = sortStateIter.GetNode()->GetInfo(); int currentEntryuCount = entriesCount; int count = 0; dTree<dState*, dCRCTYPE>::Iterator gotoIter (state->m_goto); dTree<dTree<dState*, dCRCTYPE>::dTreeNode*, int> sortGotoActions; for (gotoIter.Begin(); gotoIter; gotoIter++) { int id = symbolList.Find(gotoIter.GetKey())->GetInfo().m_tokenId; sortGotoActions.Insert(gotoIter.GetNode(), id); } dTree<dTree<dState*, dCRCTYPE>::dTreeNode*, int>::Iterator iter1 (sortGotoActions); for (iter1.Begin(); iter1; iter1++) { count ++; if ((newLine % 5) == 0) { nextGotoStateList += "\n\t\t\t"; } newLine ++; dTree<dState*, dCRCTYPE>::dTreeNode* const node = iter1.GetNode()->GetInfo(); dState* const targetState = node->GetInfo(); dGotoEntry entry; entry.m_nextState = short (targetState->m_number); entry.m_token = short(iter1.GetKey()); sprintf (text, "dGotoEntry (%d, %d), ", entry.m_token, entry.m_nextState); nextGotoStateList += text; entriesCount ++; } if ((gotoStateCount % 24) == 0) { stateGotoStart += "\n\t\t\t"; stateGotoCount += "\n\t\t\t"; } gotoStateCount ++; sprintf (text, "%d, ", currentEntryuCount); stateGotoStart += text; sprintf (text, "%d, ", count); stateGotoCount += text; } nextGotoStateList.Replace(nextGotoStateList.Size()-2, 2, ""); stateGotoCount.Replace(stateGotoCount.Size()-2, 2, ""); stateGotoStart.Replace(stateGotoStart.Size()-2, 2, ""); ReplaceMacro (templateHeader, stateGotoCount, "$(gotoCount)"); ReplaceMacro (templateHeader, stateGotoStart, "$(gotoStart)"); ReplaceMacro (templateHeader, nextGotoStateList, "$(gotoTable)"); templateHeader += endUserCode; SaveFile(outputFileName, ".cpp", templateHeader); }
int execute(TREPTR argt, int execflg, int *pf1, int *pf2) { /* `stakbot' is preserved by this routine */ register TREPTR t; STKPTR sav = savstak(); sigchk(); if ((t = argt) && execbrk == 0) { register int treeflgs; int oldexit, type; register char **com; treeflgs = t->tretyp; type = treeflgs & COMMSK; oldexit = exitval; exitval = 0; switch (type) { case TCOM: { STRING a1; int argn, internal; ARGPTR schain = gchain; IOPTR io = t->treio; gchain = 0; argn = getarg((void *)t);/*FIXME*/ com = scan(argn); a1 = com[1]; gchain = schain; if ((internal = syslook(com[0], commands)) || argn == 0) setlist(((COMPTR) t)->comset, 0); if (argn && (flags & noexec) == 0) { /* print command if execpr */ if (flags & execpr) { argn = 0; prs(execpmsg); while (com[argn] != ENDARGS) { prs(com[argn++]); blank(); } newline(); } switch (internal) { case SYSDOT: if (a1) { register int f; if ((f = pathopen(getpath(a1), a1)) < 0) failed(a1, notfound); else execexp(0, f); } break; case SYSTIMES: { struct tms t; times(&t); prt(t.tms_cutime); blank(); prt(t.tms_cstime); newline(); } break; case SYSEXIT: exitsh(a1 ? stoi(a1) : oldexit); case SYSNULL: io = 0; break; case SYSCONT: execbrk = -loopcnt; break; case SYSBREAK: if ((execbrk = loopcnt) && a1) breakcnt = stoi(a1); break; case SYSTRAP: if (a1) { BOOL clear; if ((clear = digit(*a1)) == 0) ++com; while (*++com) { int i; if ((i = stoi(*com)) >= MAXTRAP || i < MINTRAP) failed(*com, badtrap); else if (clear) clrsig(i); else { replace(&trapcom[i], a1); if (*a1) getsig(i); else ignsig(i); } } } else { /* print out current traps */ int i; for (i = 0; i < MAXTRAP; i++) { if (trapcom[i]) { prn(i); prs(colon); prs(trapcom[i]); newline(); } } } break; case SYSEXEC: com++; initio(io); ioset = 0; io = 0; if (a1 == 0) break; case SYSLOGIN: flags |= forked; oldsigs(); execa((const char **)com); done(); case SYSCD: if (flags & rshflg) failed(com[0], restricted); else if ((a1 == 0 && (a1 = (char *)homenod.namval) == 0) || chdir(a1) < 0) /* FIXME */ failed(a1, baddir); break; case SYSSHFT: if (dolc < 1) error(badshift); else { dolv++; dolc--; } assnum(&dolladr, dolc); break; case SYSWAIT: await(-1); break; case SYSREAD: exitval = readvar(&com[1]); break; /* case SYSTST: exitval=testcmd(com); break; */ case SYSSET: if (a1) { int argc; argc = options(argn, (const char **)com); if (argc > 1) setargs((const char **)com + argn - argc); } else if (((COMPTR) t)->comset == 0) /* Scan name chain and print */ namscan(printnam); break; case SYSRDONLY: exitval = N_RDONLY; case SYSXPORT: if (exitval == 0) exitval = N_EXPORT;; if (a1) { while (*++com) attrib(lookup(*com), exitval); } else { namscan(printflg); } exitval = 0; break; case SYSEVAL: if (a1) execexp(a1, (UFD)&com[2]); /* FIXME */ break; case SYSUMASK: if (a1) { int c, i; i = 0; while ((c = *a1++) >= '0' && c <= '7') i = (i << 3) + c - '0'; umask(i); } else { int i, j; umask(i = umask(0)); prc('0'); for (j = 6; j >= 0; j -= 3) prc(((i >> j) & 07) + '0'); newline(); } break; default: internal = builtin(argn, com); } if (internal) { if (io) error(illegal); chktrap(); break; } } else if (t->treio == 0) break; } case TFORK: if (execflg && (treeflgs & (FAMP | FPOU)) == 0) parent = 0; else { while ((parent = fork()) == -1) { sigchk(); alarm(10); pause(); } } if (parent) { /* This is the parent branch of fork; */ /* it may or may not wait for the child. */ if (treeflgs & FPRS && flags & ttyflg) { prn(parent); newline(); } if (treeflgs & FPCL) closepipe(pf1); if ((treeflgs & (FAMP | FPOU)) == 0) await(parent); else if ((treeflgs & FAMP) == 0) post(parent); else assnum(&pcsadr, parent); chktrap(); break; } else { /* this is the forked branch (child) of execute */ flags |= forked; iotemp = 0; postclr(); settmp(); /* Turn off INTR and QUIT if `FINT' */ /* Reset ramaining signals to parent */ /* except for those `lost' by trap */ oldsigs(); if (treeflgs & FINT) { signal(INTR, SIG_IGN); signal(QUIT, SIG_IGN); } /* pipe in or out */ if (treeflgs & FPIN) { sh_rename(pf1[INPIPE], 0); close(pf1[OTPIPE]); } if (treeflgs & FPOU) { sh_rename(pf2[OTPIPE], 1); close(pf2[INPIPE]); } /* default std input for & */ if (treeflgs & FINT && ioset == 0) sh_rename(chkopen(devnull), 0); /* io redirection */ initio(t->treio); if (type != TCOM) execute(((FORKPTR) t)->forktre, 1, NULL, NULL); else if (com[0] != ENDARGS) { setlist(((COMPTR) t)->comset, N_EXPORT); execa((const char **)com); } done(); } case TPAR: sh_rename(dup(2), output); execute(((PARPTR) t)->partre, execflg, NULL, NULL); done(); case TFIL: { int pv[2]; chkpipe(pv); if (execute(((LSTPTR) t)->lstlef, 0, pf1, pv) == 0) execute(((LSTPTR) t)->lstrit, execflg, pv, pf2); else closepipe(pv); break; } case TLST: execute(((LSTPTR) t)->lstlef, 0, NULL, NULL); execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL); break; case TAND: if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) == 0) execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL); break; case TORF: if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) != 0) execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL); break; case TFOR: { NAMPTR n = lookup(((FORPTR) t)->fornam); char **args; DOLPTR argsav = 0; if (((FORPTR) t)->forlst == 0) { args = (char **)dolv + 1; argsav = useargs(); } else { ARGPTR schain = gchain; gchain = 0; trim((args = scan(getarg(((FORPTR) t)->forlst)))[0]); gchain = schain; } loopcnt++; while (*args != ENDARGS && execbrk == 0) { assign(n, *args++); execute(((FORPTR) t)->fortre, 0, NULL, NULL); if (execbrk < 0) { execbrk = 0; } } if (breakcnt) breakcnt--; execbrk = breakcnt; loopcnt--; argfor = freeargs(argsav); break; } case TWH: case TUN: { int i = 0; loopcnt++; while (execbrk == 0 && (execute(((WHPTR) t)->whtre, 0, NULL, NULL) == 0) == (type == TWH)) { i = execute(((WHPTR) t)->dotre, 0, NULL, NULL); if (execbrk < 0) execbrk = 0; } if (breakcnt) breakcnt--; execbrk = breakcnt; loopcnt--; exitval = i; break; } case TIF: if (execute(((IFPTR) t)->iftre, 0, NULL, NULL) == 0) execute(((IFPTR) t)->thtre, execflg, NULL, NULL); else execute(((IFPTR) t)->eltre, execflg, NULL, NULL); break; case TSW: { register char *r = mactrim(((SWPTR) t)->swarg); t = (TREPTR) ((SWPTR) t)->swlst; while (t) { ARGPTR rex = ((REGPTR) t)->regptr; while (rex) { register char *s; if (gmatch(r, s = macro(rex->argval)) || (trim(s), eq(r, s))) { execute(((REGPTR)t)->regcom, 0, NULL, NULL); t = 0; break; } else rex = ((ARGPTR)rex)->argnxt; } if (t) t = (TREPTR) ((REGPTR) t)->regnxt; } } break; } exitset(); }
void WizardsPlugin::CreateClass(const NewClassInfo &info) { // Start by finding the best choice for tabs/spaces. // Use the preference for the target VirtualDir, not the active project, in case the user perversely adds to an inactive one. OptionsConfigPtr options = EditorConfigST::Get()->GetOptions(); // Globals first wxString TargetProj = info.virtualDirectory.BeforeFirst(wxT(':')); if (!TargetProj.empty()) { LocalWorkspaceST::Get()->GetOptions(options, TargetProj); // Then override with any local ones } wxString separator(wxT("\t")); if (!options->GetIndentUsesTabs()) { separator = wxString(wxT(' '), wxMax(1, options->GetTabWidth())); } wxString macro(info.blockGuard); if( macro.IsEmpty() ) { // use the name instead macro = info.name; macro.MakeUpper(); macro << (info.hppHeader ? wxT("_HPP") : wxT("_H")); } wxString headerExt = (info.hppHeader ? wxT(".hpp") : wxT(".h")); wxString srcFile; srcFile << info.path << wxFileName::GetPathSeparator() << info.fileName << wxT(".cpp"); wxString hdrFile; hdrFile << info.path << wxFileName::GetPathSeparator() << info.fileName << headerExt; //create cpp + h file wxString cpp; wxString header; //---------------------------------------------------- // header file //---------------------------------------------------- header << wxT("#ifndef ") << macro << wxT("\n"); header << wxT("#define ") << macro << wxT("\n"); header << wxT("\n"); wxString closeMethod; if (info.isInline) closeMethod << wxT('\n') << separator << wxT("{\n") << separator << wxT("}\n"); else closeMethod = wxT(";\n"); // Add include for base classes if (info.parents.empty() == false) { for (size_t i=0; i< info.parents.size(); i++) { ClassParentInfo pi = info.parents.at(i); // Include the header name only (no paths) wxFileName includeFileName(pi.fileName); header << wxT("#include \"") << includeFileName.GetFullName() << wxT("\" // Base class: ") << pi.name << wxT("\n"); } header << wxT("\n"); } // Open namespace if (!info.namespacesList.IsEmpty()) { WriteNamespacesDeclaration (info.namespacesList, header); } header << wxT("class ") << info.name; if (info.parents.empty() == false) { header << wxT(" : "); for (size_t i=0; i< info.parents.size(); i++) { ClassParentInfo pi = info.parents.at(i); header << pi.access << wxT(" ") << pi.name << wxT(", "); } header = header.BeforeLast(wxT(',')); } header << wxT("\n{\n"); if (info.isSingleton) { header << separator << wxT("static ") << info.name << wxT("* ms_instance;\n\n"); } if (info.isAssingable == false) { //declare copy constructor & assingment operator as private header << wxT("private:\n"); header << separator << info.name << wxT("(const ") << info.name << wxT("& rhs)") << closeMethod; header << separator << info.name << wxT("& operator=(const ") << info.name << wxT("& rhs)") << closeMethod; header << wxT("\n"); } if (info.isSingleton) { header << wxT("public:\n"); header << separator << wxT("static ") << info.name << wxT("* Instance();\n"); header << separator << wxT("static void Release();\n\n"); header << wxT("private:\n"); header << separator << info.name << wxT("();\n"); if (info.isVirtualDtor) { header << separator << wxT("virtual ~") << info.name << wxT("();\n\n"); } else { header << separator << wxT('~') << info.name << wxT("();\n\n"); } } else { header << wxT("public:\n"); header << separator << info.name << wxT("()") << closeMethod; if (info.isVirtualDtor) { header << separator << wxT("virtual ~") << info.name << wxT("()") << closeMethod << wxT("\n"); } else { header << separator << wxT('~') << info.name << wxT("()") << closeMethod << wxT("\n"); } } //add virtual function declaration wxString v_decl = DoGetVirtualFuncDecl(info, separator); if (v_decl.IsEmpty() == false) { header << wxT("public:\n"); header << v_decl; } header << wxT("};\n\n"); // Close namespaces for (unsigned int i = 0; i < info.namespacesList.Count(); i++) { header << wxT("}\n\n"); } header << wxT("#endif // ") << macro << wxT("\n"); wxFFile file; file.Open(hdrFile, wxT("w+b")); file.Write(header); file.Close(); //if we have a selected virtual folder, add the files to it wxArrayString paths; paths.Add(hdrFile); //---------------------------------------------------- // source file //---------------------------------------------------- if (!info.isInline) { cpp << wxT("#include \"") << info.fileName << headerExt << wxT("\"\n\n"); // Open namespace if (!info.namespacesList.IsEmpty()) { WriteNamespacesDeclaration (info.namespacesList, cpp); } if (info.isSingleton) { cpp << info.name << wxT("* ") << info.name << wxT("::ms_instance = 0;\n\n"); } //ctor/dtor cpp << info.name << wxT("::") << info.name << wxT("()\n"); cpp << wxT("{\n}\n\n"); cpp << info.name << wxT("::~") << info.name << wxT("()\n"); cpp << wxT("{\n}\n\n"); if (info.isSingleton) { cpp << info.name << wxT("* ") << info.name << wxT("::Instance()\n"); cpp << wxT("{\n"); cpp << separator << wxT("if (ms_instance == 0) {\n"); cpp << separator << separator << wxT("ms_instance = new ") << info.name << wxT("();\n"); cpp << separator << wxT("}\n"); cpp << separator << wxT("return ms_instance;\n"); cpp << wxT("}\n\n"); cpp << wxT("void ") << info.name << wxT("::Release()\n"); cpp << wxT("{\n"); cpp << separator << wxT("if (ms_instance) {\n"); cpp << separator << separator << wxT("delete ms_instance;\n"); cpp << separator << wxT("}\n"); cpp << separator << wxT("ms_instance = 0;\n"); cpp << wxT("}\n\n"); } cpp << DoGetVirtualFuncImpl(info); // Close namespaces if (info.namespacesList.Count()) { cpp << wxT('\n'); // Thow in an initial \n to separate the first namespace '}' from the previous function's one } for (unsigned int i = 0; i < info.namespacesList.Count(); i++) { cpp << wxT("}\n\n"); } file.Open(srcFile, wxT("w+b")); file.Write(cpp); file.Close(); paths.Add(srcFile); } // We have a .cpp and an .h file, and there may well be a :src and an :include folder available // So try to place the files appropriately. If that fails, dump both in the selected folder bool smartAddFiles = EditorConfigST::Get()->GetOptions()->GetOptions() & OptionsConfig::Opt_SmartAddFiles; if (!smartAddFiles || ! m_mgr->AddFilesToVirtualFolderIntelligently(info.virtualDirectory, paths) ) m_mgr->AddFilesToVirtualFolder(info.virtualDirectory, paths); // Open the newly created classes in codelite for(size_t i=0; i<paths.GetCount(); i++) { m_mgr->OpenFile(paths.Item(i)); } // Notify codelite to parse the files wxCommandEvent parseEvent(wxEVT_COMMAND_MENU_SELECTED, XRCID("retag_workspace")); EventNotifier::Get()->TopFrame()->GetEventHandler()->AddPendingEvent(parseEvent); }
#ifdef USE_PRAGMA_IDENT_HDR #pragma ident "@(#)opcodes.hpp 1.25 03/12/23 16:42:46 JVM" #endif /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ // Build a big enum of class names to give them dense integer indices #define macro(x) Op_##x, enum Opcodes { Op_Node = 0, macro(Set) // Instruction selection match rule macro(RegI) // Machine integer register macro(RegP) // Machine pointer register macro(RegF) // Machine float register macro(RegD) // Machine double register macro(RegL) // Machine long register macro(RegFlags) // Machine flags register _last_machine_leaf, // Split between regular opcodes and machine #include "classes.hpp" _last_opcode }; #undef macro // Table of names, indexed by Opcode extern const char *NodeClassNames[];
edit() { register char *p; LOCATION t_loc, loc; FILE *fp; char errbuf[ER_MAX_LEN + 1]; char input[MAX_LOC + 1]; char *editfile; char *ingedit; i4 rflag; STATUS status; i4 c; #ifdef CMS i4 Notempty = 1; #endif /* CMS */ GLOBALREF char *IIMOildInitLnDraw; FUNC_EXTERN char *getfilenm(); FUNC_EXTERN char *macro(); if (!Newline) { q_putc(Qryiop, '\n'); Newline = TRUE; } Autoclear = 0; editfile = getfilenm(); rflag = 0; if (*editfile == '\0') { rflag = 1; input[0] = EOS; if ((status = NMloc( TEMP, PATH, (char *)NULL, &t_loc)) || (status = LOuniq( ERx( "query" ), ERx( "edt" ), &t_loc))) { STcopy( ERx( "queryXXX" ), input ); } else { LOcopy( &t_loc, input, &loc ); } status = SIfopen( &loc, ERx( "w" ), (i4)SI_TXT, (i4)SI_MAX_TXT_REC, &fp ); } else { /* use the path and file name the user gave you */ STcopy(editfile, input); if (!(status = LOfroms(PATH & FILENAME, input, &loc))) status = SIfopen( &loc, ERx("w"), (i4)SI_TXT, (i4)SI_MAX_TXT_REC, &fp ); } if (status) { if (status == FAIL) errbuf[0] = '\0'; else ERreport(status, errbuf); putprintf(ERget(F_MO000C_Cant_create_qry_file), input, errbuf); cgprompt(); return(0); } if (q_ropen(Qryiop, 'r') == (struct qbuf *)NULL) /* edit: q_ropen 1 */ ipanic(E_MO0044_1500400); while ((c = (i4)q_getc(Qryiop)) > 0) SIputc((char)c, fp); SIclose(fp); if (Nodayfile >= 0) { putprintf(ERget(F_MO000D_editor_prompt)); SIflush(stdout); } /* ** macro returns NULL if undefined, UTedit uses ** default editor if passed NULL. */ /* Bug 4875 - Use editor defined by environment variable ING_EDIT. If that is not set then use the macro(editor). */ NMgtAt((ERx("ING_EDIT")), &ingedit); if ( ingedit != NULL && *ingedit != EOS ) p = ingedit; else p = macro(ERx("{editor}")); if (status = UTedit(p, &loc)) { ERreport(status, errbuf); putprintf(ERget(F_MO000E_Can_t_start_up_editor), errbuf); cgprompt(); return(0); } if (!rflag) { if (q_ropen(Qryiop, 'a') == (struct qbuf *)NULL) /* edit: q_ropen 2 */ ipanic(E_MO0045_1500401); } else { if (q_ropen(Qryiop, 'w') == (struct qbuf *)NULL) /* edit: q_ropen 3 */ ipanic(E_MO0046_1500402); if (status = SIfopen( &loc, ERx("r"), (i4)SI_TXT, (i4)SI_MAX_TXT_REC, &fp )) #ifdef CMS { Notempty = 0; } #else { ERreport(status, errbuf); /* can't reopen editfile %s: %s\n */ ipanic(E_MO0047_1500403, editfile, errbuf); } #endif /* CMS */ #ifdef CMS if (Notempty) { #endif /* CMS */ Notnull = 0; while ((c = SIgetc(fp)) != EOF) { if (status) { ERreport(status, errbuf); /* Error reading edit file: %s\n */ ipanic(E_MO0048_1500404, errbuf); } Notnull = 1; q_putc(Qryiop, (char)c); } SIclose(fp); if (status = LOpurge(&loc, 0)) { ERreport(status, errbuf); putprintf(ERget(F_MO000F_Cant_delete_file), editfile, errbuf); } #ifdef CMS } /* endif Notempty */ #endif /* CMS */ } #ifndef FT3270 /* Re-Initialize IT line drawing */ { if (Outisterm && IIMOildInitLnDraw != NULL) SIprintf(ERx("%s"), IIMOildInitLnDraw); } #endif cgprompt(); return(0); }
void makeTPlots(const Char_t *tag = ""){//"dEdx") { TString FileN(gDirectory->GetName()); gInterpreter->ProcessLine(".L Chain.C"); TChain *theChain = Chain(); TString macro(".L "); const Char_t *T = gSystem->Which(gROOT->GetMacroPath(),"T.C"); macro += T; delete [] T; macro += "+"; gInterpreter->ProcessLine(macro); // gInterpreter->ProcessLine(".L T.C+"); TT t(theChain); #if 1 TString Out = gSystem->DirName(FileN); cout << Out; TString Dir = gSystem->DirName(Out); // Out.ReplaceAll(Dir,""); if (Out.BeginsWith("/")) Out = Out.Data()+1; #else TString Out = gSystem->BaseName(FileN); Out.ReplaceAll(".root",""); #endif Out.ReplaceAll("/","_"); // if (FileN.Contains("6073006_raw") Out += "R06"; // if (FileN.Contains("6073023_raw") Out += "R23"; Out += "Plots"; Out += tag; TString Tag(tag); if (Tag.Contains("G14G",TString::kIgnoreCase) || Tag.Contains("G24G",TString::kIgnoreCase) || Tag.Contains("G34G",TString::kIgnoreCase) || Tag.Contains("G44G",TString::kIgnoreCase)) { t.SetuMinMax(2.5, 2.9); Out += "_u_2.5-2.9"; // Out += "_u_2.5-2.9_v_0-2.8"; // t.SetvMinMax(0.0, 2.8); } if (Tag.Contains("G15G",TString::kIgnoreCase)) { t.SetuMinMax(2.0, 2.5); Out += "_u_2.0-2.5"; // Out += "_u_2.5-2.9_v_0-2.8"; // t.SetvMinMax(0.0, 2.8); } if (Tag.Contains("G21G",TString::kIgnoreCase)) { t.SetVertexZCut(2.0); // cm from z = 0 } if (Tag.Contains("G22G",TString::kIgnoreCase)) { t.SetDipCut(0.9); // pT < DipCut*p } if (Tag.Contains("NoW",TString::kIgnoreCase)) { t.SetNoWafers(); } if (Tag.Contains("BL",TString::kIgnoreCase)) { t.SetLaddersInGlobal(kTRUE); } if (Tag.Contains("ssd",TString::kIgnoreCase)) { t.SetSsd(kTRUE); } if (Tag.Contains("svt",TString::kIgnoreCase)) { t.SetSvt(kTRUE); } if (Tag.Contains("east",TString::kIgnoreCase)) { if (Tag.Contains("fareast",TString::kIgnoreCase)) t.SetEastWest(3); else t.SetEastWest(1); } else { if (Tag.Contains("west",TString::kIgnoreCase)) { if (Tag.Contains("farwest",TString::kIgnoreCase)) t.SetEastWest(4); else t.SetEastWest(2); } } if (Tag.Contains("global",TString::kIgnoreCase)) { t.UseGlobal(); } if (Tag.Contains("local",TString::kIgnoreCase)) { t.UseLocal(); } if (Tag.Contains("dEdx",TString::kIgnoreCase)) { t.SetdEdxCut(4.e-6,40.); } // t.SetRCut(1.0); t.SetRCut(0.5); t.SetMinNoFitPoints(25); Out += "NFP25"; Out += Form("rCut%3.1fcm",t.GetRCut()); Out += ".root"; cout << " ===> " << Out << endl; t.SetOutFileName(Out); t.Loop(0); }
int main() {FILE *fp,*fpn,*fpo; fpa=fopen("ALA.dil","wb+"); fclose(fpa); fpa=fopen("ALA2.dil","wb+"); fclose(fpa); char stu[15];//For storing the operand so that endl value is not passed along with it int i; fpo=fopen("Output.txt","w+"); fclose(fpo); fpm=fopen("MDT.dil","wb+"); fclose(fpm);//For initialising the needed files int flag=0; fp=fopen("Input.txt","r"); while(!feof(fp)) { fscanf(fp,"%s",label); fscanf(fp,"%s",op); fscanf(fp,"%s",operand); if(flag==1) macro();//If a macro definetion is found pass-1 is called if(strcmp(op,"MACRO")==0) flag=1; //Macro definetion found, flag is set so that from next step on, it can be stored in MDT if(strcmp(op,"MEND")==0) { flag=0;s=0; fseek(fpm,0,SEEK_END); //For appending in the last, can be prevented if "a" attribute is used during the opening of file fwrite(&m,sizeof(m),1,fpm); fclose(fpm); } } rewind(fp); fpn=fopen("Input2.txt","w+");//creating the macro definetions free input for pass-2 flag=0; i=0; while(!feof(fp)) { fscanf(fp,"%s",label); fscanf(fp,"%s",op); fscanf(fp,"%s",operand); if(flag==1) {if(strcmp(op,"MACRO")!=0)//If after MEND, MACRO is not found, that is the end of macro definetions flag=2; else flag=0;} if(flag==2)//After all the definetions ended we can set the flag to 2, and copy the remaining contents into new file {fprintf(fpn,"%s\t%s\t%s\n",label,op,operand); i++; } if(strcmp(op,"MEND")==0) flag=1;//Checking whether MEND occurs } fclose(fpn); fclose(fp); printf("Pass-1 is over\nThe definetions stored in MDT are:\n"); fpm=fopen("MDT.dil","r"); while(fread(&m,sizeof(m),1,fpm)==1) printf("%s\t\t\t\t\t\t%s",m.name,m.def); fclose(fpm); fpn=fopen("Input2.txt","r"); ct=0; while(!feof(fpn)) { fscanf(fpn,"%s",label); fscanf(fpn,"%s",op); fscanf(fpn,"%s",operand); pass2(); i--; if(i==0)//To prevent the extra space of endl break; } printf("The arguements stored in ALA are:\n"); fpm=fopen("ALA2.dil","r"); while(fread(&a1,sizeof(a1),1,fpm)==1) printf("%s\t%s\n",a1.hash,a1.arg); fclose(fpm); printf("Pass-2 is over\n"); getche();//To wait, so that screen is not closed abruptly }
#include "generate_interface_impl.hpp" namespace xios { #define macro(T) \ template void CInterface::AttributeCInterface<T>(ostream& oss,const string& className,const string& name) ; \ template void CInterface::AttributeFortran2003Interface<T>(ostream& oss,const string& className,const string& name) ; \ template void CInterface::AttributeFortranInterfaceDeclaration<T>(ostream& oss,const string& className,const string& name) ; \ template void CInterface::AttributeFortranInterfaceGetDeclaration<T>(ostream& oss,const string& className,const string& name) ; \ template void CInterface::AttributeFortranInterfaceBody<T>(ostream& oss,const string& className,const string& name) ; \ template void CInterface::AttributeFortranInterfaceGetBody<T>(ostream& oss,const string& className,const string& name) ; \ template string CInterface::getStrFortranType<T>(void) ; \ template string CInterface::getStrFortranKind<T>(void) ; \ template string CInterface::getStrFortranKindC<T>(void) ; \ template bool CInterface::matchingTypeCFortran<T>(void) ; macro(bool) macro(int) macro(double) macro(CDate) macro(CDuration) }