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