void SkSVGDevice::drawBitmapCommon(const SkDraw& draw, const SkBitmap& bm, const SkPaint& paint) { SkAutoTUnref<const SkData> pngData( SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality)); if (!pngData) { return; } size_t b64Size = SkBase64::Encode(pngData->data(), pngData->size(), NULL); SkAutoTMalloc<char> b64Data(b64Size); SkBase64::Encode(pngData->data(), pngData->size(), b64Data.get()); SkString svgImageData("data:image/png;base64,"); svgImageData.append(b64Data.get(), b64Size); SkString imageID = fResourceBucket->addImage(); { AutoElement defs("defs", fWriter); { AutoElement image("image", fWriter); image.addAttribute("id", imageID); image.addAttribute("width", bm.width()); image.addAttribute("height", bm.height()); image.addAttribute("xlink:href", svgImageData); } } { AutoElement imageUse("use", fWriter, fResourceBucket, draw, paint); imageUse.addAttribute("xlink:href", SkStringPrintf("#%s", imageID.c_str())); } }
void the::material::deserialize(const pugi::xml_node &node) { unbind(); setTag(node.attribute("name").value()); std::istringstream defs(node.attribute("define").value()); std::string def; while(std::getline(defs,def, ';')) defines.push_back(def); vertexFile = node.attribute("vertex").value(); fragmentFile = node.attribute("fragment").value(); vertexShader = the::filesystem::load_as_string(aux::dataPath + vertexFile); fragmentShader = the::filesystem::load_as_string(aux::dataPath + fragmentFile); if(!node.attribute("texture0").empty()) defTextures[0] = node.attribute("texture0").value(); if(!node.attribute("texture1").empty()) defTextures[1] = node.attribute("texture1").value(); if(!node.attribute("texture2").empty()) defTextures[2] = node.attribute("texture2").value(); if(!node.attribute("texture3").empty()) defTextures[3] = node.attribute("texture3").value(); if(!node.attribute("cubemap0").empty()) defCubemaps[0] = node.attribute("cubemap0").value(); if(!node.attribute("cubemap1").empty()) defCubemaps[1] = node.attribute("cubemap1").value(); if(!node.attribute("cubemap2").empty()) defCubemaps[2] = node.attribute("cubemap2").value(); if(!node.attribute("cubemap3").empty()) defCubemaps[3] = node.attribute("cubemap3").value(); for(auto param = node.child("parameter"); param; param = param.next_sibling("parameter")) { const std::string paramName = param.attribute("name").value(); const std::string paramType = param.attribute("type").value(); userParameters[paramName] = -1; if(paramType=="float") float_param_def[paramName] = param.attribute("val").as_float(); else if(paramType=="vec4") vec4_param_def[paramName] = aux::deserialize<vec4>(param); else logger::error("Can't parse material parameter type '%s'",paramType.c_str());} }
the::material::material(precompiled::shader::shader &sh,strref d): abstract::object("Material",sh.name), vertexShader(sh.vertex), fragmentShader(sh.fragment) { std::istringstream defs(d); std::string def; while(std::getline(defs,def, ';')) defines.push_back(def); setDefines(); bind(); lookup(); logger::debug("[Material] create '%s' [%s]",getTag().c_str(),d.c_str()); }
std::vector<double> CaptureManager::GetDeformation(int c, float &avgDef) { std::vector<CvPoint> traj = GetTrajectory(c); std::vector<double> areas = GetAreas(c,avgDef); std::vector<double> defs(frameCount-1, 0.0); float totalDef = 0; int goodSteps = 0; CvSeq *h_next; ImagePlus *img_ = new ImagePlus(img); IplImage *gray = cvCreateImage(cvGetSize(img.orig), IPL_DEPTH_8U, 1); IplImage *edge = cvCreateImage(cvGetSize(img.orig), IPL_DEPTH_8U, 1); for (int i=0; i<frameCount-1; i++) { if (!(MyPoint(-1,-1)==traj[i] || MyPoint(-1,-1)==traj[i+1])) { wxPoint *ps = ContourToPointArray(Access(i,0,false, true)->contourArray[c], MyPoint(traj[i+1])-MyPoint(traj[i]).ToWxPoint()); img_->RemoveAllContours(); img_->AddContour(ps,Access(i,0,false, true)->contourArray[c]->total); delete[] ps; CvSeq *seq = Access(i+1,0,false, true)->contourArray[c]; CvSeq *oseq = img_->contourArray[0]; //Draw both contours on the temporary image cvZero(img_->orig); h_next = seq->h_next; seq->h_next = NULL; cvDrawContours(img_->orig, seq, CV_RGB(255,255,255), CV_RGB(0,0,0), 1, CV_FILLED, CV_AA, cvPoint(0,0)); seq->h_next = h_next; cvDrawContours(img_->orig, oseq, CV_RGB(255,255,200), CV_RGB(0,0,0), 1, CV_FILLED, CV_AA, cvPoint(0,0)); //detect contours on the drawn image: FindContoursPlugin::ProcessImage_static(img_,gray,edge,150,50,3,1); float unionArea = 0; for (int j=0; j<img_->contourArray.size(); j++) { unionArea += fabs(cvContourArea(img_->contourArray[j])); } goodSteps++; totalDef += (defs[i] = 2*unionArea - areas[i] - areas[i+1]); } } cvReleaseImage(&gray); cvReleaseImage(&edge); delete img_; avgDef = (goodSteps ? totalDef/goodSteps : 0); return defs; }
static void test_quant_solver(ast_manager& m, unsigned sz, app*const* xs, expr* fml, bool validate) { front_end_params params; qe::expr_quant_elim qe(m, params); qe::guarded_defs defs(m); bool success = qe.solve_for_vars(sz, xs, fml, defs); std::cout << "------------------------\n"; std::cout << mk_pp(fml, m) << "\n"; if (success) { defs.display(std::cout); for (unsigned i = 0; validate && i < defs.size(); ++i) { validate_quant_solution(m, fml, defs.guard(i), defs.defs(i)); } } else { std::cout << "failed\n"; } }
Resources SkSVGDevice::AutoElement::addResources(const SkDraw& draw, const SkPaint& paint) { Resources resources(paint); // FIXME: this is a weak heuristic and we end up with LOTS of redundant clips. bool hasClip = !draw.fClipStack->isWideOpen(); bool hasShader = SkToBool(paint.getShader()); if (hasClip || hasShader) { AutoElement defs("defs", fWriter); if (hasClip) { this->addClipResources(draw, &resources); } if (hasShader) { this->addShaderResources(paint, &resources); } } return resources; }
void SkSVGDevice::drawTextOnPath(const SkDraw&, const void* text, size_t len, const SkPath& path, const SkMatrix* matrix, const SkPaint& paint) { SkString pathID = fResourceBucket->addPath(); { AutoElement defs("defs", fWriter); AutoElement pathElement("path", fWriter); pathElement.addAttribute("id", pathID); pathElement.addPathAttributes(path); } { AutoElement textElement("text", fWriter); textElement.addTextAttributes(paint); if (matrix && !matrix->isIdentity()) { textElement.addAttribute("transform", svg_transform(*matrix)); } { AutoElement textPathElement("textPath", fWriter); textPathElement.addAttribute("xlink:href", SkStringPrintf("#%s", pathID.c_str())); if (paint.getTextAlign() != SkPaint::kLeft_Align) { SkASSERT(paint.getTextAlign() == SkPaint::kCenter_Align || paint.getTextAlign() == SkPaint::kRight_Align); textPathElement.addAttribute("startOffset", paint.getTextAlign() == SkPaint::kCenter_Align ? "50%" : "100%"); } SVGTextBuilder builder(text, len, paint, SkPoint::Make(0, 0), 0); textPathElement.addText(builder.text()); } } }
QDomNode KGameSvgDocument::def() const { return defs().at(0); }
int main(int argc, char* argv[]) { typedef double DecisionVariable_t; typedef std::mt19937 RNG_t; unsigned int seed = 1; double eta = 10; double crossover_probability = 1.0; double eps = 0.00001; double proportion_crossed = 1.0; RNG_t rng(seed); DebsSBXCrossover<RNG_t> crossover_tester(rng, eta, crossover_probability, eps, proportion_crossed); int number_dvs = 1; //number of decision variables double min_value = -1.0; double max_value = 8.0; std::vector<double> lower_bounds(number_dvs, min_value); std::vector<double> upper_bounds(number_dvs, max_value); std::vector<int> lower_bounds_i; std::vector<int> upper_bounds_i; std::vector<MinOrMaxType> min_or_max(1, MINIMISATION); // std::vector<DecisionVariable_t> parent1_dv_values {2}; // std::vector<DecisionVariable_t> parent2_dv_values {5}; ProblemDefinitions defs(lower_bounds, upper_bounds,lower_bounds_i, upper_bounds_i, min_or_max, 0); Individual parent1(defs); Individual parent2(defs); std::vector<double> results; int num_samples = 1000000; for (int i = 0; i < num_samples; ++i) { Individual child1(parent1); Individual child2(parent2); crossover_tester.crossover_implementation(child1, child2); results.push_back(child1.getRealDV(0)); results.push_back(child2.getRealDV(0)); // std::cout << child1[0] << std::endl; // std::cout << child2[0] << std::endl; } #ifdef WITH_VTK // plot results. // Set up a 2D scene, add an XY chart to it VTK_CREATE(vtkContextView, view); view->GetRenderer()->SetBackground(1.0, 1.0, 1.0); view->GetRenderWindow()->SetSize(400, 300); VTK_CREATE(vtkChartXY, chart); view->GetScene()->AddItem(chart); // Create a table with some points in it... VTK_CREATE(vtkTable, table); VTK_CREATE(vtkIntArray, arrBin); arrBin->SetName("decision variable value"); table->AddColumn(arrBin); VTK_CREATE(vtkIntArray, arrFrequency); arrFrequency->SetName("Frequency"); table->AddColumn(arrFrequency); int num_bins = 50; table->SetNumberOfRows(num_bins); std::vector<int> frequency_count(num_bins); // std::vector<std::string> bin_names(num_bins); std::vector<int> bin_names(num_bins); for (int i = 0; i < num_samples; ++i) { frequency_count[int((results[i] - min_value) / (max_value - min_value) * num_bins)]++; } for (int i = 0; i < num_bins; ++i) { // bin_names[i] = std::to_string((double(i) / double(num_bins)) * (max_value-min_value) + min_value); bin_names[i] = i; } for (int i = 0; i < num_bins; i++) { table->SetValue(i,0,bin_names[i]); table->SetValue(i,1,frequency_count[i]); } // Add multiple line plots, setting the colors etc vtkPlot *line = 0; line = chart->AddPlot(vtkChart::BAR); #if VTK_MAJOR_VERSION <= 5 line->SetInput(table, 0, 1); #else line->SetInputData(table, 0, 1); #endif line->SetColor(0, 255, 0, 255); //Finally render the scene and compare the image to a reference image view->GetRenderWindow()->SetMultiSamples(0); view->GetInteractor()->Initialize(); view->GetInteractor()->Start(); #endif }
/** * The algorithm finds conditional instruction (=condInst) first, then * corresponding CMP instruction (=cmpInst) and arithmetic instruction (=inst) * which affects flags in the same way as CMP. Combination is considered as * available to be reduced if there are no instructions between CMP and * arithmetic instruction which influence to flags or CMP operands. * * Also it transforms some conditional instruction to make them more suitable * for optimizations */ void RCE::runImpl() { Inst * inst, * cmpInst, *condInst; Opnd * cmpOp = NULL; cmpInst = condInst = NULL; const Nodes& nodes = irManager->getFlowGraph()->getNodesPostOrder(); for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) { Node* node = *it; if (node->isBlockNode()) { if(node->isEmpty()) { continue; } cmpInst = NULL; Inst* prevInst = NULL; for(inst = (Inst*)node->getLastInst(); inst != NULL; inst = prevInst) { prevInst = inst->getPrevInst(); //find conditional instruction Mnemonic baseMnem = getBaseConditionMnemonic(inst->getMnemonic()); if (baseMnem != Mnemonic_NULL) { condInst = condInst ? NULL : inst; cmpInst = NULL; } else if (condInst) { //find CMP instruction corresponds to conditional instruction if(inst->getMnemonic() == Mnemonic_CMP || inst->getMnemonic() == Mnemonic_UCOMISD || inst->getMnemonic() == Mnemonic_UCOMISS) { if (cmpInst) { //this comparison is redundant because of overrided by cmpInst inst->unlink(); continue; } cmpInst = inst; U_32 defCount = inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def); if(inst->getOpnd(defCount+1)->isPlacedIn(OpndKind_Imm)) { //try to change conditional instruction to make combination available to optimize cmpOp = inst->getOpnd(defCount); Inst * newCondInst = NULL; Mnemonic mnem; int64 val = inst->getOpnd(defCount+1)->getImmValue(); if (val == 0) { continue; } else if (val == 1 && ConditionMnemonic(condInst->getMnemonic()-getBaseConditionMnemonic(condInst->getMnemonic())) == ConditionMnemonic_L){ mnem = Mnemonic((condInst->getMnemonic() - Mnemonic(ConditionMnemonic_L)) + Mnemonic(ConditionMnemonic_LE)); } else if (val == -1 && ConditionMnemonic(condInst->getMnemonic()-getBaseConditionMnemonic(condInst->getMnemonic())) == ConditionMnemonic_G) { mnem = Mnemonic((condInst->getMnemonic() - Mnemonic(ConditionMnemonic_G)) + Mnemonic(ConditionMnemonic_GE)); } else if (val == -1 && ConditionMnemonic(condInst->getMnemonic()-getBaseConditionMnemonic(condInst->getMnemonic())) == ConditionMnemonic_B) { mnem = Mnemonic((condInst->getMnemonic() - Mnemonic(ConditionMnemonic_B)) + Mnemonic(ConditionMnemonic_BE)); } else { continue; } //replace old conditional instruction if (condInst->hasKind(Inst::Kind_BranchInst)) { BranchInst* br = (BranchInst*)condInst; newCondInst = irManager->newBranchInst(mnem,br->getTrueTarget(), br->getFalseTarget(), condInst->getOpnd(0)); } else { Mnemonic condMnem = getBaseConditionMnemonic(condInst->getMnemonic()); Inst::Opnds defs(condInst,Inst::OpndRole_Def|Inst::OpndRole_Explicit); if (condMnem == Mnemonic_CMOVcc) { Inst::Opnds uses(condInst,Inst::OpndRole_Use|Inst::OpndRole_Explicit); newCondInst = irManager->newInst(mnem, condInst->getOpnd(defs.begin()), inst->getOpnd(uses.begin())); } else if (condMnem == Mnemonic_SETcc) { newCondInst = irManager->newInst(mnem, condInst->getOpnd(defs.begin())); } else { assert(0); continue; } } newCondInst->insertAfter(condInst); condInst->unlink(); condInst = newCondInst; inst->setOpnd(defCount+1, irManager->newImmOpnd(inst->getOpnd(defCount+1)->getType(),0)); } //find flags affected instruction precedes cmpInst } else if (instAffectsFlagsAsCmpInst(inst, condInst)) { if (cmpInst) { if (isSuitableToRemove(inst, condInst, cmpInst, cmpOp)) { cmpInst->unlink(); } } condInst = NULL; // do not optimize cmpInst any more in this block } else { if (inst->getOpndCount(Inst::OpndRole_Implicit|Inst::OpndRole_Def) || inst->getMnemonic() == Mnemonic_CALL) { // instruction affects flags, skip optimizing cmpInst condInst = NULL; } else { //check for moving cmpInst operands if ((inst->getMnemonic() == Mnemonic_MOV) && (inst->getOpnd(0) == cmpOp)) { cmpOp = inst->getOpnd(1); } } } }//end if/else by condInst }//end for() by Insts }//end if BasicBlock }//end for() by Nodes }
PeepHoleOpt::Changed PeepHoleOpt::handleInst_ALU(Inst* inst) { // The normal form is 'OPERATION left opnd, right operand' // except for NOT operation. const Mnemonic mnemonic = inst->getMnemonic(); if (mnemonic == Mnemonic_NOT) { // No optimizations this time return Changed_Nothing; } // Only these mnemonics have the majestic name of ALUs. assert(mnemonic == Mnemonic_ADD || mnemonic == Mnemonic_SUB || mnemonic == Mnemonic_ADC || mnemonic == Mnemonic_SBB || mnemonic == Mnemonic_OR || mnemonic == Mnemonic_XOR || mnemonic == Mnemonic_AND || mnemonic == Mnemonic_CMP || mnemonic == Mnemonic_TEST); if (mnemonic == Mnemonic_AND) { Inst::Opnds defs(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Def); Opnd* dst = inst->getOpnd(defs.begin()); Inst::Opnds uses(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Use); Opnd* src1= inst->getOpnd(uses.begin()); Opnd* src2= inst->getOpnd(uses.next(uses.begin())); Opnd *newopnd2; // test can work only with operands having equal sizes if (isImm(src2) && src2->getSize() != src1->getSize()) newopnd2 = irManager->newImmOpnd(src1->getType(), src2->getImmValue()); else newopnd2 = src2; if (!isMem(dst) && !isMem(src1) && !isMem(src2)) { BitSet ls(irManager->getMemoryManager(), irManager->getOpndCount()); irManager->updateLivenessInfo(); irManager->getLiveAtExit(inst->getNode(), ls); for (Inst* i = (Inst*)inst->getNode()->getLastInst(); i!=inst; i = i->getPrevInst()) { irManager->updateLiveness(i, ls); } bool dstNotUsed = !ls.getBit(dst->getId()); if (dstNotUsed) { // what: AND opnd1, opnd2 => TEST opnd1, opnd2 // nb: applicable if opnd1 will not be used further if (inst->getForm() == Inst::Form_Extended) irManager->newInstEx(Mnemonic_TEST, 0, src1, newopnd2)->insertAfter(inst); else irManager->newInst(Mnemonic_TEST, src1, newopnd2)->insertAfter(inst); inst->unlink(); return Changed_Inst; } } } else if (mnemonic == Mnemonic_ADD) { /* Change "dst=src+0" to "MOV dst, src" if there is another ADD inst followed in the same BB. */ Inst::Opnds defs(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Def); Opnd* dst = inst->getOpnd(defs.begin()); Inst::Opnds uses(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Use); Opnd* src1= inst->getOpnd(uses.begin()); Opnd* src2= inst->getOpnd(uses.next(uses.begin())); bool src1IsZero = false; bool src2IsZero = false; if (src1->isPlacedIn(OpndKind_Imm) && (src1->getImmValue() == 0)) src1IsZero = true; if (src2->isPlacedIn(OpndKind_Imm) && (src2->getImmValue() == 0)) src2IsZero = true; bool anotherADD = false; Inst *iter = inst->getNextInst(); while (iter != NULL) { if (iter->getMnemonic() == Mnemonic_ADC) break; if (iter->getMnemonic() == Mnemonic_ADD) { anotherADD = true; break; } iter = iter->getNextInst();; } if (anotherADD) { if (src1IsZero) { irManager->newCopyPseudoInst(Mnemonic_MOV, dst, src2)->insertAfter(inst); inst->unlink(); return Changed_Inst; } else if (src2IsZero) { irManager->newCopyPseudoInst(Mnemonic_MOV, dst, src1)->insertAfter(inst); inst->unlink(); return Changed_Inst; } } } return Changed_Nothing; }
PeepHoleOpt::Changed PeepHoleOpt::handleInst_MUL(Inst* inst) { assert((inst->getMnemonic() == Mnemonic_IMUL) || (inst->getMnemonic() == Mnemonic_MUL)); if (inst->getForm() == Inst::Form_Native) { return Changed_Nothing; } Inst::Opnds defs(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Def); Opnd* dst1 = inst->getOpnd(defs.begin()); Opnd* dst2 = NULL; if ((inst->getMnemonic() == Mnemonic_IMUL) && (defs.next(defs.begin()) != defs.end())){ return Changed_Nothing; } else { //inst->getMnemonic() == Mnemonic_MUL dst2 = inst->getOpnd(defs.next(defs.begin())); if (defs.next(defs.next(defs.begin()))!=defs.end()) return Changed_Nothing; } Inst::Opnds uses(inst, Inst::OpndRole_Explicit|Inst::OpndRole_Use); Opnd* src1= inst->getOpnd(uses.begin()); Opnd* src2= inst->getOpnd(uses.next(uses.begin())); if (inst->getMnemonic() == Mnemonic_IMUL) assert(src1!=NULL && src2!=NULL && dst1!=NULL); else //inst->getMnemonic() == Mnemonic_MUL assert(src1!=NULL && src2!=NULL && dst1!=NULL && dst2!=NULL); if (isImm(src1)) { Opnd* tmp = src1; src1 = src2; src2 = tmp; } if (isImm(src2) && irManager->getTypeSize(src2->getType()) <=32) { int immVal = (int)src2->getImmValue(); if (immVal == 0) { if (Log::isEnabled()) Log::out()<<"I"<<inst->getId()<<" -> MUL with 0"<<std::endl; if (inst->getMnemonic() == Mnemonic_IMUL) { irManager->newCopyPseudoInst(Mnemonic_MOV, dst1, src2)->insertAfter(inst); } else { //inst->getMnemonic() == Mnemonic_MUL irManager->newCopyPseudoInst(Mnemonic_MOV, dst1, src2)->insertAfter(inst); irManager->newCopyPseudoInst(Mnemonic_MOV, dst2, src2)->insertAfter(inst); } inst->unlink(); return Changed_Inst; } else if (immVal == 1) { if (Log::isEnabled()) Log::out()<<"I"<<inst->getId()<<" -> MUL with 1"<<std::endl; if (inst->getMnemonic() == Mnemonic_IMUL) { irManager->newCopyPseudoInst(Mnemonic_MOV, dst1, src1)->insertAfter(inst); } else { //inst->getMnemonic() == Mnemonic_MUL Opnd* zero = irManager->newImmOpnd(dst1->getType(), 0); irManager->newCopyPseudoInst(Mnemonic_MOV, dst1, zero)->insertAfter(inst); irManager->newCopyPseudoInst(Mnemonic_MOV, dst2, src1)->insertAfter(inst); } inst->unlink(); return Changed_Inst; } else if (immVal == 2) { if (inst->getMnemonic() == Mnemonic_IMUL) { if (Log::isEnabled()) Log::out()<<"I"<<inst->getId()<<" -> MUL with 2"<<std::endl; irManager->newInstEx(Mnemonic_ADD, 1, dst1, src1, src1)->insertAfter(inst); inst->unlink(); return Changed_Inst; } } else { if (inst->getMnemonic() == Mnemonic_IMUL) { int minBit=getMinBit(immVal); int maxBit=getMaxBit(immVal); if (minBit == maxBit) { assert(minBit>=2); if (Log::isEnabled()) Log::out()<<"I"<<inst->getId()<<" -> MUL with 2^"<<minBit<<std::endl; Type* immType = irManager->getTypeManager().getUInt8Type(); irManager->newCopyPseudoInst(Mnemonic_MOV, dst1, src1)->insertBefore(inst); irManager->newInst(Mnemonic_SHL, dst1, irManager->newImmOpnd(immType, minBit))->insertBefore(inst); inst->unlink(); return Changed_Inst; } } } } return Changed_Nothing; }
int main( int argc, char **argv ) { int i; FILE *skeleton, *temp, *tokout, *actout; int ch; char tempfname[10]; char *fileprefix = "y"; size_t size; param_requested = 0; for( i = 1; i < argc; ++i ) { ch = argv[i][0]; switch( param_requested ) { case 'b': if( ch != '-' ) { if( ch != '\0' ) fileprefix = argv[i]; ++i; } break; case 'p': if( ch != '-' ) { if( ch != '\0' ) symprefix = argv[i]; ++i; } break; default: break; } param_requested = 0; if( argv[i][0] != '-' ) break; setoptions( &argv[i][1] ); } if( i != argc - 1 && i != argc - 2 ) { puts( "usage: yacc [-dlv] [-d[bcdfhpstuw]] [-b <file_prefix>] [-p <sym_prefix>]" ); puts( " <grammar> [<driver>]" ); puts( "options:" ); puts( " -b <file_prefix> file prefix used in place of default 'y' prefix" ); puts( " -d output header file" ); puts( " -db output bigger (less optimal) tables" ); puts( " -dc output compact tables (slower to execute)" ); puts( " -dd use dense tokens (no '+' style tokens allowed)" ); puts( " -de dump all symbols to header file as enum items, no macros" ); puts( " -df output fast tables (larger size)" ); puts( " -dh use 'default shift' optimization" ); puts( " -dp dump all productions" ); puts( " -ds dump full state tables" ); puts( " -dt translate 'keyword' to Y_KEYWORD, '++' to Y_PLUS_PLUS, etc." ); puts( " -du eliminate useless unit production reduction" ); puts( " -dw disable default action type checking" ); puts( " -l output #line directives" ); puts( " -p <sym_prefix> symbol prefix used in place of default 'yy' prefix" ); puts( " -v write description and report into file" ); exit( 1 ); } skeleton = NULL; if( i == argc - 2 ) { skeleton = openr( argv[argc - 1] ); if( skeleton == NULL ) { msg( "could not open driver source code '%s'\n", argv[argc - 1] ); } } loadpath = argv[0]; *getname( loadpath ) = '\0'; srcname = argv[i]; if( !strrchr( srcname, '.' ) ) { srcname = alloca( strlen( argv[i] )+3 ); srcname = strcat( strcpy( srcname, argv[i] ), ".y" ); } yaccin = openr( srcname ); size = strlen( fileprefix); codefilename = MALLOC( size + 6, char ); strcat( strcpy( codefilename, fileprefix), "tab.c" ); headerfilename = MALLOC( size + 6, char ); strcat( strcpy( headerfilename, fileprefix), "tab.h" ); descfilename = MALLOC( size + 5, char ); strcat( strcpy( descfilename, fileprefix), ".out" ); actout = openw( codefilename ); defs( actout ); tokout = openw( headerfilename ); dump_header( tokout ); temp = NULL; for( i = 0; i < 1000 && temp == NULL; ++i ) { sprintf( tempfname, "ytab.%3d", i ); temp = fopen( tempfname, "w+" ); } if( temp == NULL ) { msg( "Cannot create temporary file\n" ); } rules( temp ); buildpro(); CalcMinSentence(); if( proflag || showflag ) { showpro(); } lr0(); lalr1(); SetupStateTable(); /* apply state filters */ FindUnused(); if( eliminateunitflag ) { EliminateUnitReductions(); } if( default_shiftflag ) { if( keyword_id_low == 0 ) { msg( "No %%keyword_id <low> <high> specified." ); } else { MarkDefaultShifts(); } } MarkNoUnitRuleOptimizationStates(); RemoveDeadStates(); MarkDefaultReductions(); if( showflag ) { showstates(); } if( warnings ) { if( warnings == 1 ) { printf( "%s: 1 warning\n", srcname ); } else { printf( "%s: %d warnings\n", srcname, warnings ); } exit( 1 ); } parsestats(); dumpstatistic( "parser states", nstate ); dumpstatistic( "# states (1 reduce only)", nstate_1_reduce ); dumpstatistic( "reduce/reduce conflicts", RR_conflicts ); dumpstatistic( "shift/reduce conflicts", SR_conflicts ); show_unused(); if( skeleton == NULL ) { skeleton = fpopen( loadpath, "yydriver.c" ); if( skeleton == NULL ) { warn( "Can't find yacc skeleton yydriver.c\n" ); } } /* copy first part of skeleton */ if( skeleton != NULL ) copy_part( skeleton, actout ); rewind( tokout ); /* copy tokens */ copy_rest( tokout, actout ); close_header( tokout ); genobj( actout ); /* copy middle part of skeleton */ if( skeleton != NULL ) copy_part( skeleton, actout ); rewind( temp ); copy_rest( temp, actout ); fclose( temp ); remove( tempfname ); /* copy last part of skeleton */ if( skeleton != NULL ) { copy_rest( skeleton, actout ); fclose( skeleton ); } tail( actout ); fclose( actout ); FREE( codefilename ); FREE( headerfilename ); FREE( descfilename ); return( 0 ); }
void SvgElementVisitor::visit(clan::DomElement &e) { if (e.get_namespace_uri() != Svg::svg_ns) return; // To do: do a more efficient search for the correct handler auto local_name = e.get_local_name(); if (local_name == "a") a(e); else if (local_name == "altGlyph") altGlyph(e); else if (local_name == "altGlyphDef") altGlyphDef(e); else if (local_name == "altGlyphItem") altGlyphItem(e); else if (local_name == "animate") animate(e); else if (local_name == "animateColor") animateColor(e); else if (local_name == "animateMotion") animateMotion(e); else if (local_name == "animateTransform") animateTransform(e); else if (local_name == "circle") circle(e); else if (local_name == "clipPath") clipPath(e); else if (local_name == "color-profile") color_profile(e); else if (local_name == "cursor") cursor(e); else if (local_name == "defs") defs(e); else if (local_name == "desc") desc(e); else if (local_name == "ellipse") ellipse(e); else if (local_name == "feBlend") feBlend(e); else if (local_name == "feColorMatrix") feColorMatrix(e); else if (local_name == "feComponentTransfer") feComponentTransfer(e); else if (local_name == "feComposite") feComposite(e); else if (local_name == "feConvolveMatrix") feConvolveMatrix(e); else if (local_name == "feDiffuseLighting") feDiffuseLighting(e); else if (local_name == "feDisplacementMap") feDisplacementMap(e); else if (local_name == "feDistantLight") feDistantLight(e); else if (local_name == "feFlood") feFlood(e); else if (local_name == "feFuncA") feFuncA(e); else if (local_name == "feFuncB") feFuncB(e); else if (local_name == "feFuncG") feFuncG(e); else if (local_name == "feFuncR") feFuncR(e); else if (local_name == "feGaussianBlur") feGaussianBlur(e); else if (local_name == "feImage") feImage(e); else if (local_name == "feMerge") feMerge(e); else if (local_name == "feMergeNode") feMergeNode(e); else if (local_name == "feMorphology") feMorphology(e); else if (local_name == "feOffset") feOffset(e); else if (local_name == "fePointLight") fePointLight(e); else if (local_name == "feSpecularLighting") feSpecularLighting(e); else if (local_name == "feSpotLight") feSpotLight(e); else if (local_name == "feTile") feTile(e); else if (local_name == "feTurbulence") feTurbulence(e); else if (local_name == "filter") filter(e); else if (local_name == "font") font(e); else if (local_name == "font-face") font_face(e); else if (local_name == "font-face-format") font_face_format(e); else if (local_name == "font-face-name") font_face_name(e); else if (local_name == "font-face-src") font_face_src(e); else if (local_name == "font-face-uri") font_face_uri(e); else if (local_name == "foreignObject") foreignObject(e); else if (local_name == "g") g(e); else if (local_name == "glyph") glyph(e); else if (local_name == "glyphRef") glyphRef(e); else if (local_name == "hkern") hkern(e); else if (local_name == "image") image(e); else if (local_name == "line") line(e); else if (local_name == "linearGradient") linearGradient(e); else if (local_name == "marker") marker(e); else if (local_name == "mask") mask(e); else if (local_name == "metadata") metadata(e); else if (local_name == "missing-glyph") missing_glyph(e); else if (local_name == "mpath") mpath(e); else if (local_name == "path") path(e); else if (local_name == "pattern") pattern(e); else if (local_name == "polygon") polygon(e); else if (local_name == "polyline") polyline(e); else if (local_name == "radialGradient") radialGradient(e); else if (local_name == "rect") rect(e); else if (local_name == "script") script(e); else if (local_name == "set") set(e); else if (local_name == "stop") stop(e); else if (local_name == "style") style(e); else if (local_name == "svg") svg(e); else if (local_name == "switch") switch_(e); else if (local_name == "symbol") symbol(e); else if (local_name == "text") text(e); else if (local_name == "textPath") textPath(e); else if (local_name == "title") title(e); else if (local_name == "tref") tref(e); else if (local_name == "tspan") tspan(e); else if (local_name == "use") use(e); else if (local_name == "view") view(e); else if (local_name == "vkern") vkern(e); }