// Compiles HLSL code into executable binaries
ShaderBlob *Renderer::compileToBinary(gl::InfoLog &infoLog, const char *hlsl, const char *profile, UINT optimizationFlags, bool alternateFlags)
{
if (!hlsl)
{
return NULL;
}
HRESULT result = S_OK;
UINT flags = 0;
std::string sourceText;
if (gl::perfActive())
{
flags |= D3DCOMPILE_DEBUG;
#ifdef NDEBUG
flags |= optimizationFlags;
#else
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
#endif
std::string sourcePath = getTempPath();
sourceText = std::string("#line 2 \"") + sourcePath + std::string("\"\n\n") + std::string(hlsl);
writeFile(sourcePath.c_str(), sourceText.c_str(), sourceText.size());
}
else
{
flags |= optimizationFlags;
sourceText = hlsl;
}
// Sometimes D3DCompile will fail with the default compilation flags for complicated shaders when it would otherwise pass with alternative options.
// Try the default flags first and if compilation fails, try some alternatives.
const static UINT extraFlags[] =
{
0,
D3DCOMPILE_AVOID_FLOW_CONTROL,
D3DCOMPILE_PREFER_FLOW_CONTROL
};
const static char * const extraFlagNames[] =
{
"default",
"avoid flow control",
"prefer flow control"
};
int attempts = alternateFlags ? ArraySize(extraFlags) : 1;
pD3DCompile compileFunc = reinterpret_cast<pD3DCompile>(mD3DCompileFunc);
for (int i = 0; i < attempts; ++i)
{
ID3DBlob *errorMessage = NULL;
ID3DBlob *binary = NULL;
result = compileFunc(hlsl, strlen(hlsl), gl::g_fakepath, NULL, NULL,
"main", profile, flags | extraFlags[i], 0, &binary, &errorMessage);
if (errorMessage)
{
const char *message = (const char*)errorMessage->GetBufferPointer();
infoLog.appendSanitized(message);
TRACE("\n%s", hlsl);
TRACE("\n%s", message);
errorMessage->Release();
errorMessage = NULL;
}
if (SUCCEEDED(result))
{
return (ShaderBlob*)binary;
}
else
{
#if defined(ANGLE_PLATFORM_WINRT)
if (result == E_OUTOFMEMORY)
#else
if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY)
#endif // #if defined(ANGLE_PLATFORM_WINRT)
{
return gl::error(GL_OUT_OF_MEMORY, (ShaderBlob*) NULL);
}
infoLog.append("Warning: D3D shader compilation failed with ");
infoLog.append(extraFlagNames[i]);
infoLog.append(" flags.");
if (i + 1 < attempts)
{
infoLog.append(" Retrying with ");
infoLog.append(extraFlagNames[i + 1]);
infoLog.append(".\n");
}
}
}
return NULL;
}
void DL_Jww::CreateMoji(DL_CreationInterface* creationInterface, CDataMoji& DMoji)
{
string lName = HEX[DMoji.m_nGLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DMoji.m_nGLayer] + "-" +
HEX[DMoji.m_nLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DMoji.m_nLayer];
// add layer
creationInterface->addLayer(DL_LayerData(lName,0));
int width;
if(DMoji.m_nPenWidth > 26)
width = 0;
else
width = DMoji.m_nPenWidth;
int color = colTable[DMoji.m_nPenColor > ArraySize(colTable)-1 ? ArraySize(colTable)-1 : DMoji.m_nPenColor];
attrib = DL_Attributes(values[8], // layer
color, // color
width, // width
lTable[DMoji.m_nPenStyle > ArraySize(lTable)-1 ? ArraySize(lTable)-1 : DMoji.m_nPenStyle]); // linetype
creationInterface->setAttributes(attrib);
creationInterface->setExtrusion(0.0, 0.0, 1.0, 0.0 );
DL_TextData d(
// insertion point
DMoji.m_start.x, DMoji.m_start.y, 0.0,
// alignment point
0.0, 0.0, 0.0,
// height
DMoji.m_dSizeY,
// x scale
1.0,
// generation flags
0,
// h just
0,
// v just
0,
// text
DMoji.m_string,
// style
string("japanese"),
// angle
DMoji.m_degKakudo / 180.0 * M_PI);
creationInterface->addText(d);
#ifdef FINISHED
QTextCodec* codec = QTextCodec::codecForName("SJIS");
RS_TextData data3(RS_Vector(0.0, 0.0),
10,//double height,
10,//double width,
RS2::VAlignMiddle,
RS2::HAlignCenter,
RS2::LeftToRight,
RS2::AtLeast,
1.0,//double lineSpacingFactor,
RS_String(""),//const RS_String& text,
RS_String(""),
0.0,//double angle,
RS2::Update);
RS_Text* text;
data3.insertionPoint = RS_Vector(DMoji.m_start.x, DMoji.m_start.y);
data3.height = DMoji.m_dSizeY;
data3.width = DMoji.m_dSizeX;
data3.valign = RS2::VAlignBottom;//VAlignMiddle;
data3.halign = RS2::HAlignLeft;//HAlignCenter;
data3.drawingDirection = RS2::LeftToRight;
data3.lineSpacingStyle = RS2::Exact;
data3.lineSpacingFactor = DMoji.m_dKankaku;//1.0;
//コード変換
size_t left = DMoji.m_string.length();
char* sjis = (char *)DMoji.m_string.c_str();
char buf[200];
//memset(buf, NULL, 1000);
char* p = buf;
size_t bufleft = 200;
#ifdef _WINDOWS
// エンコーディングの変換：iconvを使う場合
iconv_t cd = iconv_open(UTF8_CES, SHIFTJIS_CES);
#ifdef DEBUG
printf("sjis = %x, p = %x\n", sjis, p);
#endif
size_t r = iconv(cd, (const char **)(&sjis), &left, &p, &bufleft);//const_cast<char**>
#ifdef DEBUG
printf("sjis = %x, p = %x\n", sjis, p);
printf("sjis = %x %x %x %x, p = %x %x %x %x\n", sjis[0],sjis[1],sjis[2],sjis[3], buf[0],buf[1],buf[2],buf[3]);
printf("r = %d, left = %d, bufleft = %d\n", r, left, bufleft);
#endif
*p = '\0';
iconv_close(cd);
#else
// int ires = SJIS2UTF8N(sjis,buf,bufleft);
int nBytesOut;
strcpy(buf,(const char *)CUnicodeF::sjis_to_euc((const unsigned char *)sjis/*, &nBytesOut*/));
// QTextCodec* codec = QTextCodec::codecForName("eucJP");
// data3.text = codec->toUnicode(buf);
#endif
// data3.text = codec->toUnicode(sjis);
data3.text = RS_String::fromUtf8(buf);
data3.style = RS_String("japanese-euc");
data3.angle = DMoji.m_degKakudo / 180.0 * M_PI;
#ifdef DEBUG
RS_DEBUG->setLevel(RS_Debug::D_DEBUGGING);
#endif
data3.updateMode = RS2::Update;
//jwDWORD m_nMojiShu;//文字種(斜体文字は20000、ボールド体は10000を加えた数値)
text = new RS_Text(graphic, data3);
RS2::LineType ltype = lTable[DMoji.m_nPenStyle];
RS_Color col = colTable[DMoji.m_nPenColor];
RS2::LineWidth lw = lWidth[DMoji.m_nPenWidth > 26 ? 0 : DMoji.m_nPenWidth];//RS2::Width12
text->setPen(RS_Pen(col, RS2::Width08, ltype));
//画層設定
RS_String lName = HEX[DMoji.m_nGLayer > 0x0f ? 0: DMoji.m_nGLayer] + "-" +
HEX[DMoji.m_nLayer > 0x0f ? 0 : DMoji.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
#ifdef DEBUG
std::cout << lName.ascii() << std::endl;
#endif
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
text->setLayer(lName);
// add the line to the graphic
graphic->addEntity(text);
#ifdef DEBUG
std::cout << data3.height << " " << data3.width << std::endl;
std::cout << *text;
#endif
#endif
}
void encodeExpToDjango(char *outFile)
/* Write out Django model declaration for encodeExp into outfile. */
{
FILE *f = mustOpen(outFile, "w");
/* Write series model. */
fprintf(f, "\n");
fprintf(f, "class Series(models.Model):\n");
fprintf(f, " \"\"\"\n");
fprintf(f, " Represents a series of experiments of the same type done for\n");
fprintf(f, " the same project.\n");
fprintf(f, " \"\"\"\n");
fprintf(f, " term = models.CharField(max_length=50)\n");
fprintf(f, " dataType = models.CharField(max_length=40)\n");
fprintf(f, " grantee = models.CharField(max_length=255)\n");
fprintf(f, "\n");
fprintf(f, " class Meta:\n");
fprintf(f, " db_table = '%s%s'\n", cvDbPrefix, "series");
fprintf(f, "\n");
fprintf(f, " def __unicode__(self):\n");
fprintf(f, " return self.term\n");
fprintf(f, "\n");
/* Write experiment model. */
fprintf(f, "\n");
fprintf(f, "class Experiment(models.Model):\n");
fprintf(f, " \"\"\"\n");
fprintf(f, " A defined set of conditions for an experiment. There may be\n");
fprintf(f, " multiple replicates of an experiment, but they are all done\n");
fprintf(f, " under the same conditions. Often many experiments are done in\n");
fprintf(f, " a 'Series' under sets of conditions that vary in defined ways\n");
fprintf(f, " Some experiments may be designated controls for the series.\n ");
fprintf(f, " \"\"\"\n");
int i;
for (i=1; i<ArraySize(expRequiredFields); ++i) // Start at one so django makes id field itself
{
struct field *field = &expRequiredFields[i];
fprintf(f, " %s = models.%s\n", field->name, field->djangoType);
}
for (i=0; i<ArraySize(expOptionalFields); ++i)
{
char *name = expOptionalFields[i];
fprintf(f, " %s = models.ForeignKey(%c%s, db_column='%s', blank=True, null=True)\n",
name, toupper(name[0]), name+1, name);
}
fprintf(f, "\n");
fprintf(f, " class Meta:\n");
fprintf(f, " db_table = '%s%s'\n", cvDbPrefix, "experiment");
fprintf(f, "\n");
fprintf(f, " def __unicode__(self):\n");
fprintf(f, " return self.accession\n");
fprintf(f, "\n");
/* Write results model. */
fprintf(f, "\n");
fprintf(f, "class Result(models.Model):\n");
fprintf(f, " \"\"\"\n");
fprintf(f, " A result of an experiment - generally either a data file or a\n");
fprintf(f, " database table. Intermediate as well as final results may be found\n");
fprintf(f, " here. Some results may be replicated a number of times\n");
fprintf(f, " \"\"\"\n");
fprintf(f, " experiment = models.ForeignKey(Experiment, db_column='experiment')\n");
fprintf(f, " replicate = models.CharField(max_length=50, blank=True)\n");
fprintf(f, " view = models.CharField(max_length=50)\n");
fprintf(f, " objType = models.CharField(max_length=50)\n");
fprintf(f, " fileName = models.CharField(max_length=255)\n");
fprintf(f, " md5sum = models.CharField(max_length=255)\n");
fprintf(f, " tableName = models.CharField(max_length=100, blank=True)\n");
fprintf(f, " dateSubmitted = models.CharField(max_length=40)\n");
fprintf(f, " dateResubmitted = models.CharField(max_length=40, blank=True)\n");
fprintf(f, " dateUnrestricted = models.CharField(max_length=40)\n");
fprintf(f, "\n");
fprintf(f, " class Meta:\n");
fprintf(f, " db_table = '%s%s'\n", cvDbPrefix, "results");
fprintf(f, "\n");
fprintf(f, " def __unicode__(self):\n");
fprintf(f, " return self.fileName\n");
fprintf(f, "\n");
carefulClose(&f);
}
void initArray()
{
int i;
for (i=0; i<ArraySize(functionStrings); i++)
functionFound[i] = FALSE;
}
void DL_Jww::CreateSen(DL_CreationInterface* creationInterface, CDataSen& DSen)
{
string lName = HEX[DSen.m_nGLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DSen.m_nGLayer] + "-" +
HEX[DSen.m_nLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DSen.m_nLayer];
// add layer
creationInterface->addLayer(DL_LayerData(lName,0));
//#ifdef DEBUG
if(DSen.m_nPenStyle > ArraySize(lTable)-1)
std::cout << "線種番号 " << (jwWORD)DSen.m_nPenStyle << std::endl; //線種番号
if(DSen.m_nPenColor > ArraySize(colTable)-1)
std::cout << "線色番号 " << (jwWORD)DSen.m_nPenColor << std::endl; //線色番号
if(DSen.m_nPenWidth > 26)
std::cout << "線色幅 " << (jwWORD)DSen.m_nPenWidth << std::endl;//線色幅
//#endif
int width;
if(DSen.m_nPenWidth > 26)
width = 0;
else
width = DSen.m_nPenWidth;
int color = colTable[DSen.m_nPenColor > ArraySize(colTable)-1 ? ArraySize(colTable)-1 : DSen.m_nPenColor];
attrib = DL_Attributes(values[8], // layer
color, // color
width, // width
lTable[DSen.m_nPenStyle > ArraySize(lTable)-1 ? ArraySize(lTable)-1 : DSen.m_nPenStyle]); // linetype
creationInterface->setAttributes(attrib);
creationInterface->setExtrusion(0.0, 0.0, 1.0, 0.0 );
// correct some impossible attributes for layers:
/*
attrib = creationInterface->getAttributes();
if (attrib.getColor()==256 || attrib.getColor()==0) {
attrib.setColor(7);
}
if (attrib.getWidth()<0) {
attrib.setWidth(1);
}
if (!strcasecmp(attrib.getLineType().c_str(), "BYLAYER") ||
!strcasecmp(attrib.getLineType().c_str(), "BYBLOCK")) {
attrib.setLineType("CONTINUOUS");
}
*/
DL_LineData d(DSen.m_start.x,
DSen.m_start.y,
0.0,
DSen.m_end.x,
DSen.m_end.y,
0.0);
creationInterface->addLine(d);
#ifdef FINISHED
RS_LineData data(RS_Vector(0.0, 0.0), RS_Vector(0.0, 0.0));
RS_Line* line;
data.startpoint = RS_Vector(DSen.m_start.x, DSen.m_start.y);
data.endpoint = RS_Vector(DSen.m_end.x, DSen.m_end.y);
line = new RS_Line(graphic, data);
RS2::LineType ltype = lTable[DSen.m_nPenStyle];
RS_Color col = colTable[DSen.m_nPenColor];
RS2::LineWidth lw = lWidth[DSen.m_nPenWidth>26 ? 0 : DSen.m_nPenWidth];
line->setPen(RS_Pen(col, lw, ltype));
//画層設定
//画層
// m_nGLayer-m_nLayer
//_0-0_ から_0-F_
// ...
//_F-0_ から_F-F_
RS_String lName = HEX[DSen.m_nGLayer > 0x0f ? 0: DSen.m_nGLayer] + "-" +
HEX[DSen.m_nLayer > 0x0f ? 0: DSen.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
#ifdef DEBUG
cout << jwdoc->vSen[i].m_nGLayer << " " << jwdoc->vSen[i].m_nLayer << endl;
std::cout << lName.ascii() << std::endl;
#endif
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
line->setLayer(lName);
#ifdef DEBUG
std::cout << "線種番号 " << (jwWORD)DSen.m_nPenStyle << std::endl; //線種番号
std::cout << "線色番号 " << (jwWORD)DSen.m_nPenColor << std::endl; //線色番号
std::cout << "線色幅 " << (jwWORD)DSen.m_nPenWidth << std::endl;//線色幅
#endif
// add the line to the graphic
graphic->addEntity(line);
std::cout << *line;
#endif
}
static struct hash *makeCvHash()
/* Turn a bunch of lists of words into hashes for fast lookup of whether
* something is in a controlled vocabulary. */
{
/* These are just code generate things pasted in for now. May do something more elegant and
* prettier later */
char *assay[] =
{
"ATAC-seq",
"broad-ChIP-seq",
"DNAse-seq",
"exome",
"Hi-C",
"long-RNA-seq",
"methyl-ChIP-seq",
"narrow-ChIP-seq",
"RIP-seq",
"short-RNA-seq",
"WGBS",
"WGS",
};
char *control[] =
{
"untreated",
"input",
"mock IP",
};
char *disease[] =
{
"DCM",
"HCM",
"LQT",
"TNM stage IIA, grade 3, ductal carcinoma",
"chronic myelogenous leukemia (CML)",
"LQT",
"acute promyelocytic leukemia",
};
char *enriched_in[] =
{
"coding",
"exon",
"genome",
"intron",
"open",
"promoter",
"unknown",
"utr",
"utr3",
"utr5",
};
char *formats[] =
{
"bam",
"bam.bai",
"bed",
"bigBed",
"bigWig",
"cram",
"fasta",
"fastq",
"gtf",
"html",
"idat",
"jpg",
"pdf",
"rcc",
"text",
"vcf",
"unknown",
};
char *sequencer[] =
{
"Illumina HiSeq",
"Illumina HiSeq 2000",
"Illumina HiSeq 2500",
"Illumina HiSeq 3000",
"Illumina HiSeq 4000",
"Illumina HiSeq X Five",
"Illumina HiSeq X Ten",
"Illumina MiSeq",
"Illumina MiSeq Dx",
"Illumina MiSeq FGx",
"Illumina NextSeq 500",
"Illumina unknown",
"PacBio RS II",
"Ion Torrent Ion Proton",
"Ion Torrent Ion PGM",
"Ion Torrent Ion Chef",
"454 GS FLX+ ",
"454 GS Junior+ ",
"SN7001226",
"HiSeq G0821 SN605",
"HiSeq at Illumina 700422R",
"MiSeq G0823 M00361",
};
char *species[] =
{
"H**o sapiens",
"Mus musculus",
};
char *strain[] =
{
"C57BL/6",
"BALB/c",
"Sftpc-Cre-ER-T2A-rtta -/- teto-GFP-H2B +/-",
"Aqp5-Cre-ER +/- mtmg-tdTomato -/-",
};
char *target_epitope[] =
{
"H3K4Me1",
"H3K4Me3",
"H3K27Ac",
"H3K27Me3",
"5mC",
"5hmC",
};
struct hash *hash = hashNew(0);
hashAdd(hash, "assay", makeStringHash(assay, ArraySize(assay)));
hashAdd(hash, "control", makeStringHash(control, ArraySize(control)));
hashAdd(hash, "disease", makeStringHash(disease, ArraySize(disease)));
hashAdd(hash, "enriched_in", makeStringHash(enriched_in, ArraySize(enriched_in)));
hashAdd(hash, "formats", makeStringHash(formats, ArraySize(formats)));
hashAdd(hash, "sequencer", makeStringHash(sequencer, ArraySize(sequencer)));
hashAdd(hash, "species", makeStringHash(species, ArraySize(species)));
hashAdd(hash, "strain", makeStringHash(strain, ArraySize(strain)));
hashAdd(hash, "target_epitope", makeStringHash(target_epitope, ArraySize(target_epitope)));
return hash;
}
/*
** Attempt to load an SQLite extension library contained in the file
** zFile. The entry point is zProc. zProc may be 0 in which case a
** default entry point name (sqlite3_extension_init) is used. Use
** of the default name is recommended.
**
** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
**
** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
** error message text. The calling function should free this memory
** by calling sqlite3DbFree(db, ).
*/
static int sqlite3LoadExtension(
sqlite3 *db, /* Load the extension into this database connection */
const char *zFile, /* Name of the shared library containing extension */
const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
char **pzErrMsg /* Put error message here if not 0 */
){
sqlite3_vfs *pVfs = db->pVfs;
void *handle;
int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
char *zErrmsg = 0;
const char *zEntry;
char *zAltEntry = 0;
void **aHandle;
int nMsg = 300 + sqlite3Strlen30(zFile);
int ii;
/* Shared library endings to try if zFile cannot be loaded as written */
static const char *azEndings[] = {
#if SQLITE_OS_WIN
"dll"
#elif defined(__APPLE__)
"dylib"
#else
"so"
#endif
};
if( pzErrMsg ) *pzErrMsg = 0;
/* Ticket #1863. To avoid a creating security problems for older
** applications that relink against newer versions of SQLite, the
** ability to run load_extension is turned off by default. One
** must call sqlite3_enable_load_extension() to turn on extension
** loading. Otherwise you get the following error.
*/
if( (db->flags & SQLITE_LoadExtension)==0 ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("not authorized");
}
return SQLITE_ERROR;
}
zEntry = zProc ? zProc : "sqlite3_extension_init";
handle = sqlite3OsDlOpen(pVfs, zFile);
#if SQLITE_OS_UNIX || SQLITE_OS_WIN
for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
if( zAltFile==0 ) return SQLITE_NOMEM;
handle = sqlite3OsDlOpen(pVfs, zAltFile);
sqlite3_free(zAltFile);
}
#endif
if( handle==0 ){
if( pzErrMsg ){
*pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"unable to open shared library [%s]", zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
}
}
return SQLITE_ERROR;
}
xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
sqlite3OsDlSym(pVfs, handle, zEntry);
/* If no entry point was specified and the default legacy
** entry point name "sqlite3_extension_init" was not found, then
** construct an entry point name "sqlite3_X_init" where the X is
** replaced by the lowercase value of every ASCII alphabetic
** character in the filename after the last "/" upto the first ".",
** and eliding the first three characters if they are "lib".
** Examples:
**
** /usr/local/lib/libExample5.4.3.so ==> sqlite3_example_init
** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init
*/
if( xInit==0 && zProc==0 ){
int iFile, iEntry, c;
int ncFile = sqlite3Strlen30(zFile);
zAltEntry = sqlite3_malloc(ncFile+30);
if( zAltEntry==0 ){
sqlite3OsDlClose(pVfs, handle);
return SQLITE_NOMEM;
}
memcpy(zAltEntry, "sqlite3_", 8);
for(iFile=ncFile-1; iFile>=0 && zFile[iFile]!='/'; iFile--){}
iFile++;
if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;
for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){
if( sqlite3Isalpha(c) ){
zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];
}
}
memcpy(zAltEntry+iEntry, "_init", 6);
zEntry = zAltEntry;
xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
sqlite3OsDlSym(pVfs, handle, zEntry);
}
if( xInit==0 ){
if( pzErrMsg ){
nMsg += sqlite3Strlen30(zEntry);
*pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"no entry point [%s] in shared library [%s]", zEntry, zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
}
}
sqlite3OsDlClose(pVfs, handle);
sqlite3_free(zAltEntry);
return SQLITE_ERROR;
}
sqlite3_free(zAltEntry);
if( xInit(db, &zErrmsg, &sqlite3Apis) ){
if( pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
}
sqlite3_free(zErrmsg);
sqlite3OsDlClose(pVfs, handle);
return SQLITE_ERROR;
}
/* Append the new shared library handle to the db->aExtension array. */
aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
if( aHandle==0 ){
return SQLITE_NOMEM;
}
if( db->nExtension>0 ){
memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
}
sqlite3DbFree(db, db->aExtension);
db->aExtension = aHandle;
db->aExtension[db->nExtension++] = handle;
return SQLITE_OK;
}
static struct bed4 *parseRegionInput(char *db, char *inputString, int maxRegions, int maxErrs,
struct dyString *dyWarn)
/* scan the user region definition, turn into a bed list */
{
int regionCount = 0;
int errCount = 0;
struct bed4 *bedList = NULL;
struct lineFile *lf = lineFileOnString("userData", TRUE, inputString);
char *line = NULL;
while (lineFileNextReal(lf, &line))
{
char *chromName = NULL;
int chromStart = 0;
int chromEnd = 0;
char *regionName = NULL;
// Chop a copy of line so we can display line if there's an error.
char copy[strlen(line)+1];
safecpy(copy, sizeof(copy), line);
char *words[5];
int wordCount = chopByWhite(copy, words, ArraySize(words));
boolean badFormat = FALSE;
boolean gotError = FALSE;
/* might be something of the form: chrom:start-end optionalRegionName */
if (((1 == wordCount) || (2 == wordCount)) &&
hgParseChromRange(NULL, words[0], &chromName,
&chromStart, &chromEnd))
{
if (2 == wordCount)
regionName = cloneString(words[1]);
}
else if (!((3 == wordCount) || (4 == wordCount)))
{
dyStringPrintf(dyWarn, "line %d: '%s': "
"unrecognized format. Please enter 3- or 4-column BED or "
"a chr:start-end position range optionally followed by a name.\n",
lf->lineIx, line);
badFormat = TRUE;
gotError = TRUE;
}
else
{
chromName = words[0];
// Make sure chromStart and chromEnd are numbers
if (!isNumericString(words[1]))
{
dyStringPrintf(dyWarn, "line %d: '%s': chromStart must be a number but is '%s'\n",
lf->lineIx, line, words[1]);
gotError = TRUE;
}
if (!isNumericString(words[2]))
{
dyStringPrintf(dyWarn, "line %d: '%s': chromEnd must be a number but is '%s'\n",
lf->lineIx, line, words[2]);
gotError = TRUE;
}
if (! gotError)
{
chromStart = atoi(words[1]);
chromEnd = atoi(words[2]);
if (wordCount > 3)
regionName = cloneString(words[3]);
}
}
char *officialChromName = chromName ? hgOfficialChromName(db, chromName) : NULL;
if (! badFormat)
{
if (NULL == officialChromName)
{
dyStringPrintf(dyWarn,
"line %d: '%s': chrom name '%s' not recognized in this assembly\n",
lf->lineIx, line, chromName ? chromName : words[0]);
gotError = TRUE;
}
else if (illegalCoordinate(db, officialChromName, chromStart, chromEnd, line, lf->lineIx,
dyWarn))
{
gotError = TRUE;
}
}
if (gotError)
{
errCount++;
if (errCount > maxErrs && maxErrs > 0)
{
dyStringPrintf(dyWarn, "Exceeded maximum number of errors (%d), quitting\n", maxErrs);
break;
}
else
continue;
}
++regionCount;
if (regionCount > maxRegions && maxRegions > 0)
{
dyStringPrintf(dyWarn,
"line %d: limit of %d region definitions exceeded, skipping the rest\n",
lf->lineIx, maxRegions);
break;
}
struct bed4 *bedEl = bed4New(officialChromName, chromStart, chromEnd, regionName);
slAddHead(&bedList, bedEl);
}
lineFileClose(&lf);
// Keep regions in same order as user entered them:
slReverse(&bedList);
return (bedList);
}
jboolean RegisterIndex8Gray(JNIEnv *env)
{
return RegisterPrimitives(env, Index8GrayPrimitives,
ArraySize(Index8GrayPrimitives));
}
void askForSeq(char *organism, char *db)
/* Put up a little form that asks for sequence.
* Call self.... */
{
struct serverTable *serve = NULL;
/* JavaScript to update form when org changes */
char *onChangeText = "onchange=\""
"document.mainForm.changeInfo.value='orgChange';"
"document.mainForm.submit();\"";
char *userSeq = NULL;
serve = findServer(db, FALSE);
printf(
"<FORM ACTION=\"../cgi-bin/hgBlat\" METHOD=\"POST\" ENCTYPE=\"multipart/form-data\" NAME=\"mainForm\">\n"
"<H2>BLAT Search Genome</H2>\n");
cartSaveSession(cart);
puts("\n");
puts("<INPUT TYPE=HIDDEN NAME=changeInfo VALUE=\"\">\n");
puts("<TABLE BORDER=0 WIDTH=80>\n<TR>\n");
printf("<TD ALIGN=CENTER>Genome:</TD>");
printf("<TD ALIGN=CENTER>Assembly:</TD>");
printf("<TD ALIGN=CENTER>Query type:</TD>");
printf("<TD ALIGN=CENTER>Sort output:</TD>");
printf("<TD ALIGN=CENTER>Output type:</TD>");
printf("<TD ALIGN=CENTER> </TD>");
printf("</TR>\n<TR>\n");
printf("<TD ALIGN=CENTER>\n");
printBlatGenomeListHtml(db, onChangeText);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
printBlatAssemblyListHtml(db);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("type", typeList, ArraySize(typeList), NULL);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("sort", sortList, ArraySize(sortList), cartOptionalString(cart, "sort"));
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("output", outputList, ArraySize(outputList), cartOptionalString(cart, "output"));
printf("</TD>\n");
printf("</TR>\n<TR>\n");
userSeq = cartUsualString(cart, "userSeq", "");
printf("<TD COLSPAN=5 ALIGN=CENTER>\n");
printf("<TEXTAREA NAME=userSeq ROWS=14 COLS=80>%s</TEXTAREA>\n", userSeq);
printf("</TD>\n");
printf("</TR>\n<TR>\n");
printf("<TD COLSPAN=5 ALIGN=CENTER>\n");
printf("<INPUT TYPE=SUBMIT NAME=Submit VALUE=submit>\n");
printf("<INPUT TYPE=SUBMIT NAME=Lucky VALUE=\"I'm feeling lucky\">\n");
printf("<INPUT TYPE=SUBMIT NAME=Clear VALUE=clear>\n");
printf("</TD>\n");
printf("</TR>\n<TR>\n");
puts("<TD COLSPAN=5 WIDTH=\"100%\">\n"
"Paste in a query sequence to find its location in the\n"
"the genome. Multiple sequences may be searched \n"
"if separated by lines starting with '>' followed by the sequence name.\n"
"</TD>\n"
"</TR>\n"
);
puts("<TR><TD COLSPAN=5 WIDTH=\"100%\">\n");
puts("<BR><B>File Upload:</B> ");
puts("Rather than pasting a sequence, you can choose to upload a text file containing "
"the sequence.<BR>");
puts("Upload sequence: <INPUT TYPE=FILE NAME=\"seqFile\">");
puts(" <INPUT TYPE=SUBMIT Name=Submit VALUE=\"submit file\"><P>\n");
printf("%s",
"<P>Only DNA sequences of 25,000 or fewer bases and protein or translated \n"
"sequence of 10000 or fewer letters will be processed. Up to 25 sequences\n"
"can be submitted at the same time. The total limit for multiple sequence\n"
"submissions is 50,000 bases or 25,000 letters.\n</P>");
if (hgPcrOk(db))
printf("<P>For locating PCR primers, use <A HREF=\"../cgi-bin/hgPcr?db=%s\">In-Silico PCR</A>"
" for best results instead of BLAT.</P>", db);
puts("</TD></TR></TABLE>\n");
printf("</FORM>\n");
webNewSection("About BLAT");
printf(
"<P>BLAT on DNA is designed to\n"
"quickly find sequences of 95%% and greater similarity of length 25 bases or\n"
"more. It may miss more divergent or shorter sequence alignments. It will find\n"
"perfect sequence matches of 20 bases.\n"
"BLAT on proteins finds sequences of 80%% and greater similarity of length 20 amino\n"
"acids or more. In practice DNA BLAT works well on primates, and protein\n"
"blat on land vertebrates."
);
printf("%s",
"\n</P><P>BLAT is not BLAST. DNA BLAT works by keeping an index of the entire genome\n"
"in memory. The index consists of all overlapping 11-mers stepping by 5 except for\n"
"those heavily involved in repeats. The index takes up about\n"
"2 gigabytes of RAM. RAM can be further reduced to less than 1 GB by increasing step size to 11.\n"
"The genome itself is not kept in memory, allowing\n"
"BLAT to deliver high performance on a reasonably priced Linux box.\n"
"The index is used to find areas of probable homology, which are then\n"
"loaded into memory for a detailed alignment. Protein BLAT works in a similar\n"
"manner, except with 4-mers rather than 11-mers. The protein index takes a little\n"
"more than 2 gigabytes.</P>\n"
"<P>BLAT was written by <A HREF=\"mailto:[email protected]\">Jim Kent</A>.\n"
"Like most of Jim's software, interactive use on this web server is free to all.\n"
"Sources and executables to run batch jobs on your own server are available free\n"
"for academic, personal, and non-profit purposes. Non-exclusive commercial\n"
"licenses are also available. See the \n"
"<A HREF=\"http://www.kentinformatics.com\" TARGET=_blank>Kent Informatics</A>\n"
"website for details.</P>\n"
"\n"
"<P>For more information on the graphical version of BLAT, click the Help \n"
"button on the top menu bar");
if (hIsGsidServer())
printf(". </P> \n");
else
printf(" or see the Genome Browser <A HREF=\"../FAQ/FAQblat.html\">FAQ</A>. </P> \n");
}
bits64 finishAndWriteOneSlot(bits32 *offsetArray, bits32 *listArray,
bits32 slotFirstIx, DNA *allDna, FILE *f)
/* Do additional sorting and write results to file. Return amount actually written. */
{
bits64 basesIndexed = 0;
bits32 elIx, nextElIx;
if (slotFirstIx != 0)
{
/* Do in affect a secondary bucket sort on the 14-17th bases. */
bits32 buckets[256];
bits32 bucketIx;
for (bucketIx = 0; bucketIx < ArraySize(buckets); bucketIx += 1)
buckets[bucketIx] = 0;
for (elIx = slotFirstIx; elIx != 0; elIx = nextElIx)
{
nextElIx = listArray[elIx];
int bucketIx = binary4(allDna + offsetArray[elIx] + 13U);
if (bucketIx >= 0)
{
listArray[elIx] = buckets[bucketIx];
buckets[bucketIx] = elIx;
++basesIndexed;
}
}
/* Do final sorting within buckets. */
for (bucketIx = 0; bucketIx < ArraySize(buckets); ++bucketIx )
{
bits32 firstIx = buckets[bucketIx];
if (firstIx != 0)
{
bits32 secondIx = listArray[firstIx];
if (secondIx == 0)
{
/* Special case for size one list, there are lots of these! */
writeOne(f, offsetArray[firstIx]);
}
else
{
if (listArray[secondIx] == 0)
{
bits32 firstOffset = offsetArray[firstIx];
bits32 secondOffset = offsetArray[secondIx];
/* Special case for size two list. There are still quite a few of these. */
if (strcmp(allDna+firstOffset, allDna+secondOffset) < 0)
{
writeOne(f, secondOffset);
writeOne(f, firstOffset);
}
else
{
writeOne(f, firstOffset);
writeOne(f, secondOffset);
}
}
else
{
/* Three or more - do it the hard way... */
sortAndWriteOffsets(firstIx, offsetArray, listArray, allDna, f);
}
}
}
}
}
return basesIndexed;
}
void trimUniq(bioSeq *seqList)
/* Check that all seq's in list have a unique name. Try and
* abbreviate longer sequence names. */
{
struct hash *hash = newHash(0);
bioSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
{
char *saferString = needMem(strlen(seq->name)+1);
char *c, *s;
/* Some chars are safe to allow through, other chars cause
* problems. It isn't necessarily a URL safe string that is
* being calculated here. The original problem was a user had
* the fasta header line of:
* chr8|59823648:59825047|+
* The plus sign was being taken as the query name and this
* created problems as that name was passed on to hgc via
* the ss cart variable. The + sign became part of a URL
* eventually. This loop allows only isalnum and =_/.:;_|
* to get through as part of the header name. These characters
* all proved to be safe as single character names, or all
* together.
*/
s = saferString;
for (c = seq->name; *c != '\0'; ++c)
{
if (c && (*c != '\0'))
{
if ( isalnum(*c) || (*c == '=') || (*c == '-') || (*c == '/') ||
(*c == '.') || (*c == ':') || (*c == ';') || (*c == '_') ||
(*c == '|') )
*s++ = *c;
}
}
*s = '\0';
freeMem(seq->name);
if (*saferString == '\0')
{
freeMem(saferString);
saferString = cloneString("YourSeq");
}
seq->name = saferString;
if (strlen(seq->name) > 14) /* Try and get rid of long NCBI .fa cruft. */
{
char *nameClone = NULL;
char *abbrv = NULL;
char *words[32];
int wordCount;
boolean isEns = (stringIn("ENSEMBL:", seq->name) != NULL);
nameClone = cloneString(seq->name);
wordCount = chopString(nameClone, "|", words, ArraySize(words));
if (wordCount > 1) /* Looks like it's an Ensembl/NCBI
* long name alright. */
{
if (isEns)
{
abbrv = words[0];
if (abbrv[0] == 0) abbrv = words[1];
}
else if (sameString(words[1], "dbSNP"))
{
if (wordCount > 2)
abbrv = words[2];
else
abbrv = nameClone;
}
else
{
abbrv = words[wordCount-1];
if (abbrv[0] == 0) abbrv = words[wordCount-2];
}
if (hashLookup(hash, abbrv) == NULL)
{
freeMem(seq->name);
seq->name = cloneString(abbrv);
}
freez(&nameClone);
}
}
hashAddUnique(hash, seq->name, hash);
}
freeHash(&hash);
}
/*
** Return the current value of a status parameter.
*/
SQLITE_PRIVATE int sqlite3StatusValue(int op){
wsdStatInit;
assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
return wsdStat.nowValue[op];
}
bool Renderer::initializeCompiler()
{
TRACE_EVENT0("gpu", "initializeCompiler");
#if defined(ANGLE_PLATFORM_WP8)
mD3dCompilerModule = NULL;
mD3DCompileFunc = NULL;
mHasCompiler = false;
return true;
#endif //#if defined(ANGLE_PLATFORM_WP8)
#if defined(ANGLE_PLATFORM_WINRT) && (_MSC_VER >= 1800)
ERR("No D3D compiler module available - must use precompiled shaders\n");
mD3dCompilerModule = NULL;
mD3DCompileFunc = reinterpret_cast<pCompileFunc>(D3DCompile);
mHasCompiler = true;
return true;
#endif // #if defined(ANGLE_PLATFORM_WINRT) && (_MSC_VER >= 1800)
#if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES)
// Find a D3DCompiler module that had already been loaded based on a predefined list of versions.
static TCHAR* d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES;
for (size_t i = 0; i < ArraySize(d3dCompilerNames); ++i)
{
if (GetModuleHandleEx(0, d3dCompilerNames[i], &mD3dCompilerModule))
{
break;
}
}
#else
// Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
#if defined(ANGLE_PLATFORM_WINRT)
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
#else
mD3dCompilerModule = LoadPackagedLibrary((LPCWSTR)D3DCOMPILER_DLL, 0);
#endif
if (!mD3dCompilerModule)
{
ERR("No D3D compiler module found - must use precompiled shaders\n");
mD3DCompileFunc = NULL;
mHasCompiler = false;
return true;
}
#else
mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
#endif //
#endif // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES
if (!mD3dCompilerModule)
{
ERR("No D3D compiler module found - aborting!\n");
mHasCompiler = FALSE;
return false;
}
mD3DCompileFunc = reinterpret_cast<pCompileFunc>(GetProcAddress(mD3dCompilerModule, "D3DCompile"));
ASSERT(mD3DCompileFunc);
return mD3DCompileFunc != NULL;
}
jboolean RegisterIntRgb(JNIEnv *env)
{
return RegisterPrimitives(env, IntRgbPrimitives,
ArraySize(IntRgbPrimitives));
}
void LoadPlugs(const TCHAR* ModuleName)
{
HANDLE hSScr=Info.SaveScreen(0,0,-1,-1);
{
const TCHAR* MsgItems[]={GetMsg(mName),GetMsg(mLoading)};
Info.Message(&MainGuid,&MessageLoadingGuid,0,NULL,MsgItems,sizeof(MsgItems)/sizeof(MsgItems[0]),0);
}
TCHAR PluginsFolder[MAX_PATH],PluginsMask[MAX_PATH],*NamePtr;
lstrcpy(UnknownPluginName,GetMsg(mUnknown));
lstrcpy(PluginsFolder,ModuleName);
NamePtr=(TCHAR*)FSF.PointToName(PluginsFolder);
lstrcpy(NamePtr,_T("\\Formats\\"));
wsprintf(PluginsMask,_T("%s*.fmt"),PluginsFolder);
HANDLE FindHandle;
WIN32_FIND_DATA fdata;
int Done=((FindHandle=FindFirstFile(PluginsMask,&fdata))==INVALID_HANDLE_VALUE);
while(!Done)
{
TCHAR PluginName[MAX_PATH];
wsprintf(PluginName,_T("%s%s"),PluginsFolder,fdata.cFileName);
HMODULE hModule=LoadLibrary(PluginName);
if (hModule!=NULL)
{
struct PluginItem CurPlugin;
CurPlugin.hModule=hModule;
CurPlugin.Type=0;
CurPlugin.pLoadSyntaxModule=(PLUGINLOADSYNTAXMODULE)GetProcAddress(hModule,"LoadSyntaxModule");
CurPlugin.pSetColorizeInfo=(PLUGINSETCOLORIZEINFO)GetProcAddress(hModule,"SetColorizeInfo");
CurPlugin.pGetParams=(PLUGINGETPARAMS)GetProcAddress(hModule,"GetParams");
CurPlugin.pColorize=(PLUGINCOLORIZE)GetProcAddress(hModule,"Colorize");
CurPlugin.pInput=(PLUGININPUT)GetProcAddress(hModule,"Input");
CurPlugin.pGetSyntaxCount=(PLUGINGETSYNTAXCOUNT)GetProcAddress(hModule,"GetSyntaxCount");
CurPlugin.pExit=(PLUGINEXIT)GetProcAddress(hModule,"Exit");
if(CurPlugin.pLoadSyntaxModule)
CurPlugin.Type=CurPlugin.pLoadSyntaxModule(PluginName,&Info);
int accept_plug=true;
if(CurPlugin.pSetColorizeInfo)
{
ColorizeInfo lInfo;
lInfo.size=sizeof(lInfo);
lInfo.version=VER_ALL;
lInfo.api=VER_API;
lInfo.cachestr=PARSER_CACHESTR;
lstrcpy(lInfo.folder,PluginsFolder);
lInfo.pAddColor=addcolor;
lInfo.pGetLine=getline;
lInfo.pAddState=addstate;
lInfo.pGetCursor=getcursor;
lInfo.pCallParser=callparser;
accept_plug=CurPlugin.pSetColorizeInfo(&lInfo);
}
if(accept_plug)
{
unsigned long subcount=1;
if(CurPlugin.pGetSyntaxCount)
subcount=CurPlugin.pGetSyntaxCount();
if(subcount)
{
struct PluginItem *NewPluginsData=(struct PluginItem *)realloc(PluginsData,sizeof(*PluginsData)*(PluginsCount+subcount));
if (NewPluginsData==NULL)
break;
PluginsData=NewPluginsData;
for(unsigned long i=0;i<subcount;i++)
{
CurPlugin.Index=i;
CurPlugin.Mask=NULL;
CurPlugin.Start=NULL;
CurPlugin.Params=0;
const TCHAR *mask,*start,*name=NULL;
TCHAR buff_mask[2048],buff_start[2048];
lstrcpy(buff_mask,_T("")); lstrcpy(buff_start,_T(""));
if(CurPlugin.pGetParams)
{
CurPlugin.Params=CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_PARAMS,NULL);
CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_NAME,(const char**)&name);
//load mask
if(name&&(CurPlugin.Params&PAR_MASK_CACHE))
{
if(!CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_MASK,(const char**)&mask))
mask=_T("");
lstrcpy(buff_mask,mask);
if(CurPlugin.Params&PAR_MASK_STORE)
{
CFarSettings settings(MainGuid);
settings.Change(PLUGIN_MASK_KEY);
settings.Get(name,buff_mask,ArraySize(buff_mask));
}
}
//load starts
if(name&&(CurPlugin.Params&PAR_FILESTART_CACHE))
{
if(!CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_FILESTART,(const char**)&start))
start=_T("");
lstrcpy(buff_start,start);
if(CurPlugin.Params&PAR_FILESTART_STORE)
{
CFarSettings settings(MainGuid);
settings.Change(PLUGIN_START_KEY);
settings.Get(name,buff_start,ArraySize(buff_start));
}
}
}
if(name) CurPlugin.Name=name;
else CurPlugin.Name=UnknownPluginName;
if(lstrlen(buff_mask))
CurPlugin.Mask=(TCHAR*)malloc((lstrlen(buff_mask)+1)*sizeof(TCHAR));
if(CurPlugin.Mask)
lstrcpy(CurPlugin.Mask,buff_mask);
if(lstrlen(buff_start))
CurPlugin.Start=(TCHAR*)malloc((lstrlen(buff_start)+1)*sizeof(TCHAR));
if(CurPlugin.Start)
lstrcpy(CurPlugin.Start,buff_start);
if(CurPlugin.pGetParams)
{ //load colors
int ColorCount; ABColor* Colors;
if((CurPlugin.Params&PAR_COLORS_STORE)&&CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_COLOR_COUNT,(const char **)&ColorCount)&&CurPlugin.pGetParams(CurPlugin.Index,PAR_GET_COLOR,(const char **)&Colors))
{
LoadColors(name,Colors,ColorCount);
}
}
PluginsData[PluginsCount]=CurPlugin;
PluginsCount++;
}
}
}
else
FreeLibrary(hModule);
}
Done=!FindNextFile(FindHandle,&fdata);
}
FindClose(FindHandle);
Info.RestoreScreen(hSScr);
}
errAbort("%s is not a valid TABIX index file", fileNameOnly(path));
}
boolean cdwIsGzipped(char *path)
/* Return TRUE if file at path starts with GZIP signature */
{
FILE *f = mustOpen(path, "r");
int first = fgetc(f);
int second = fgetc(f);
carefulClose(&f);
return first == 0x1F && second == 0x8B;
}
static char *edwSupportedEnrichedIn[] = {"unknown", "exon", "intron", "promoter", "coding",
"utr", "utr3", "utr5", "open"};
static int edwSupportedEnrichedInCount = ArraySize(edwSupportedEnrichedIn);
boolean cdwCheckEnrichedIn(char *enriched)
/* return TRUE if value is allowed */
{
return (stringArrayIx(enriched, edwSupportedEnrichedIn, edwSupportedEnrichedInCount) >= 0);
}
struct cdwBedType cdwBedTypeTable[] = {
{"bedLogR", 9, 1},
{"bedRnaElements", 6, 3},
{"bedRrbs", 9, 2},
{"bedMethyl", 9, 2},
{"narrowPeak", 6, 4},
{"broadPeak", 6, 3},
};
/*
** Process a pragma statement.
**
** Pragmas are of this form:
**
** PRAGMA [database.]id [= value]
**
** The identifier might also be a string. The value is a string, and
** identifier, or a number. If minusFlag is true, then the value is
** a number that was preceded by a minus sign.
**
** If the left side is "database.id" then pId1 is the database name
** and pId2 is the id. If the left side is just "id" then pId1 is the
** id and pId2 is any empty string.
*/
void sqlite3Pragma(
Parse *pParse,
Token *pId1, /* First part of [database.]id field */
Token *pId2, /* Second part of [database.]id field, or NULL */
Token *pValue, /* Token for <value>, or NULL */
int minusFlag /* True if a '-' sign preceded <value> */
){
char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
const char *zDb = 0; /* The database name */
Token *pId; /* Pointer to <id> token */
int iDb; /* Database index for <database> */
sqlite3 *db = pParse->db;
Db *pDb;
Vdbe *v = sqlite3GetVdbe(pParse);
if( v==0 ) return;
/* Interpret the [database.] part of the pragma statement. iDb is the
** index of the database this pragma is being applied to in db.aDb[]. */
iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
if( iDb<0 ) return;
pDb = &db->aDb[iDb];
/* If the temp database has been explicitly named as part of the
** pragma, make sure it is open.
*/
if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
return;
}
zLeft = sqlite3NameFromToken(pId);
if( !zLeft ) return;
if( minusFlag ){
zRight = sqlite3MPrintf("-%T", pValue);
}else{
zRight = sqlite3NameFromToken(pValue);
}
zDb = ((iDb>0)?pDb->zName:0);
if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
goto pragma_out;
}
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
/*
** PRAGMA [database.]default_cache_size
** PRAGMA [database.]default_cache_size=N
**
** The first form reports the current persistent setting for the
** page cache size. The value returned is the maximum number of
** pages in the page cache. The second form sets both the current
** page cache size value and the persistent page cache size value
** stored in the database file.
**
** The default cache size is stored in meta-value 2 of page 1 of the
** database file. The cache size is actually the absolute value of
** this memory location. The sign of meta-value 2 determines the
** synchronous setting. A negative value means synchronous is off
** and a positive value means synchronous is on.
*/
if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
static const VdbeOpList getCacheSize[] = {
{ OP_ReadCookie, 0, 2, 0}, /* 0 */
{ OP_AbsValue, 0, 0, 0},
{ OP_Dup, 0, 0, 0},
{ OP_Integer, 0, 0, 0},
{ OP_Ne, 0, 6, 0},
{ OP_Integer, 0, 0, 0}, /* 5 */
{ OP_Callback, 1, 0, 0},
};
int addr;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
if( !zRight ){
sqlite3VdbeSetNumCols(v, 1);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P3_STATIC);
addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
sqlite3VdbeChangeP1(v, addr, iDb);
sqlite3VdbeChangeP1(v, addr+5, MAX_PAGES);
}else{
int size = atoi(zRight);
if( size<0 ) size = -size;
sqlite3BeginWriteOperation(pParse, 0, iDb);
sqlite3VdbeAddOp(v, OP_Integer, size, 0);
sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2);
addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3);
sqlite3VdbeAddOp(v, OP_Negative, 0, 0);
sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2);
pDb->pSchema->cache_size = size;
sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
}
}else
/*
** PRAGMA [database.]page_size
** PRAGMA [database.]page_size=N
**
** The first form reports the current setting for the
** database page size in bytes. The second form sets the
** database page size value. The value can only be set if
** the database has not yet been created.
*/
if( sqlite3StrICmp(zLeft,"page_size")==0 ){
Btree *pBt = pDb->pBt;
if( !zRight ){
int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
returnSingleInt(pParse, "page_size", size);
}else{
sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1);
}
}else
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
/*
** PRAGMA [database.]auto_vacuum
** PRAGMA [database.]auto_vacuum=N
**
** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
*/
#ifndef SQLITE_OMIT_AUTOVACUUM
if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
Btree *pBt = pDb->pBt;
if( !zRight ){
int auto_vacuum =
pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
}else{
sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight));
}
}else
#endif
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
/*
** PRAGMA [database.]cache_size
** PRAGMA [database.]cache_size=N
**
** The first form reports the current local setting for the
** page cache size. The local setting can be different from
** the persistent cache size value that is stored in the database
** file itself. The value returned is the maximum number of
** pages in the page cache. The second form sets the local
** page cache size value. It does not change the persistent
** cache size stored on the disk so the cache size will revert
** to its default value when the database is closed and reopened.
** N should be a positive integer.
*/
if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
if( !zRight ){
returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
}else{
int size = atoi(zRight);
if( size<0 ) size = -size;
pDb->pSchema->cache_size = size;
sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
}
}else
/*
** PRAGMA temp_store
** PRAGMA temp_store = "default"|"memory"|"file"
**
** Return or set the local value of the temp_store flag. Changing
** the local value does not make changes to the disk file and the default
** value will be restored the next time the database is opened.
**
** Note that it is possible for the library compile-time options to
** override this setting
*/
if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
if( !zRight ){
returnSingleInt(pParse, "temp_store", db->temp_store);
}else{
changeTempStorage(pParse, zRight);
}
}else
/*
** PRAGMA temp_store_directory
** PRAGMA temp_store_directory = ""|"directory_name"
**
** Return or set the local value of the temp_store_directory flag. Changing
** the value sets a specific directory to be used for temporary files.
** Setting to a null string reverts to the default temporary directory search.
** If temporary directory is changed, then invalidateTempStorage.
**
*/
if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
if( !zRight ){
if( sqlite3_temp_directory ){
sqlite3VdbeSetNumCols(v, 1);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
"temp_store_directory", P3_STATIC);
sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0);
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
}
}else{
if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){
sqlite3ErrorMsg(pParse, "not a writable directory");
goto pragma_out;
}
if( TEMP_STORE==0
|| (TEMP_STORE==1 && db->temp_store<=1)
|| (TEMP_STORE==2 && db->temp_store==1)
){
invalidateTempStorage(pParse);
}
sqliteFree(sqlite3_temp_directory);
if( zRight[0] ){
sqlite3_temp_directory = zRight;
zRight = 0;
}else{
sqlite3_temp_directory = 0;
}
}
}else
/*
** PRAGMA [database.]synchronous
** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
**
** Return or set the local value of the synchronous flag. Changing
** the local value does not make changes to the disk file and the
** default value will be restored the next time the database is
** opened.
*/
if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
if( !zRight ){
returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
}else{
if( !db->autoCommit ){
sqlite3ErrorMsg(pParse,
"Safety level may not be changed inside a transaction");
}else{
pDb->safety_level = getSafetyLevel(zRight)+1;
}
}
}else
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
#ifndef SQLITE_OMIT_FLAG_PRAGMAS
if( flagPragma(pParse, zLeft, zRight) ){
/* The flagPragma() subroutine also generates any necessary code
** there is nothing more to do here */
}else
#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
/*
** PRAGMA table_info(<table>)
**
** Return a single row for each column of the named table. The columns of
** the returned data set are:
**
** cid: Column id (numbered from left to right, starting at 0)
** name: Column name
** type: Column declaration type.
** notnull: True if 'NOT NULL' is part of column declaration
** dflt_value: The default value for the column, if any.
*/
if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
Table *pTab;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
pTab = sqlite3FindTable(db, zRight, zDb);
if( pTab ){
int i;
Column *pCol;
sqlite3VdbeSetNumCols(v, 6);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P3_STATIC);
sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P3_STATIC);
sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P3_STATIC);
sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P3_STATIC);
sqlite3ViewGetColumnNames(pParse, pTab);
for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0, pCol->zName, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
pCol->zType ? pCol->zType : "", 0);
sqlite3VdbeAddOp(v, OP_Integer, pCol->notNull, 0);
sqlite3ExprCode(pParse, pCol->pDflt);
sqlite3VdbeAddOp(v, OP_Integer, pCol->isPrimKey, 0);
sqlite3VdbeAddOp(v, OP_Callback, 6, 0);
}
}
}else
if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
Index *pIdx;
Table *pTab;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
pIdx = sqlite3FindIndex(db, zRight, zDb);
if( pIdx ){
int i;
pTab = pIdx->pTable;
sqlite3VdbeSetNumCols(v, 3);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P3_STATIC);
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P3_STATIC);
for(i=0; i<pIdx->nColumn; i++){
int cnum = pIdx->aiColumn[i];
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
sqlite3VdbeAddOp(v, OP_Integer, cnum, 0);
assert( pTab->nCol>cnum );
sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0);
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
}
}
}else
if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
Index *pIdx;
Table *pTab;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
pTab = sqlite3FindTable(db, zRight, zDb);
if( pTab ){
v = sqlite3GetVdbe(pParse);
pIdx = pTab->pIndex;
if( pIdx ){
int i = 0;
sqlite3VdbeSetNumCols(v, 3);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P3_STATIC);
while(pIdx){
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0);
sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0);
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
++i;
pIdx = pIdx->pNext;
}
}
}
}else
if( sqlite3StrICmp(zLeft, "database_list")==0 ){
int i;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
sqlite3VdbeSetNumCols(v, 3);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P3_STATIC);
for(i=0; i<db->nDb; i++){
if( db->aDb[i].pBt==0 ) continue;
assert( db->aDb[i].zName!=0 );
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
}
}else
if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
int i = 0;
HashElem *p;
sqlite3VdbeSetNumCols(v, 2);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC);
for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
CollSeq *pColl = (CollSeq *)sqliteHashData(p);
sqlite3VdbeAddOp(v, OP_Integer, i++, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0);
sqlite3VdbeAddOp(v, OP_Callback, 2, 0);
}
}else
#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
#ifndef SQLITE_OMIT_FOREIGN_KEY
if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
FKey *pFK;
Table *pTab;
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
pTab = sqlite3FindTable(db, zRight, zDb);
if( pTab ){
v = sqlite3GetVdbe(pParse);
pFK = pTab->pFKey;
if( pFK ){
int i = 0;
sqlite3VdbeSetNumCols(v, 5);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P3_STATIC);
sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P3_STATIC);
sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P3_STATIC);
sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P3_STATIC);
while(pFK){
int j;
for(j=0; j<pFK->nCol; j++){
char *zCol = pFK->aCol[j].zCol;
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
sqlite3VdbeAddOp(v, OP_Integer, j, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0);
sqlite3VdbeAddOp(v, OP_Callback, 5, 0);
}
++i;
pFK = pFK->pNextFrom;
}
}
}
}else
#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
#ifndef NDEBUG
if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
extern void sqlite3ParserTrace(FILE*, char *);
if( zRight ){
if( getBoolean(zRight) ){
sqlite3ParserTrace(stderr, "parser: ");
}else{
sqlite3ParserTrace(0, 0);
}
}
}else
#endif
/* Reinstall the LIKE and GLOB functions. The variant of LIKE
** used will be case sensitive or not depending on the RHS.
*/
if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
if( zRight ){
sqlite3RegisterLikeFunctions(db, getBoolean(zRight));
}
}else
#ifndef SQLITE_OMIT_INTEGRITY_CHECK
if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){
int i, j, addr;
/* Code that appears at the end of the integrity check. If no error
** messages have been generated, output OK. Otherwise output the
** error message
*/
static const VdbeOpList endCode[] = {
{ OP_MemLoad, 0, 0, 0},
{ OP_Integer, 0, 0, 0},
{ OP_Ne, 0, 0, 0}, /* 2 */
{ OP_String8, 0, 0, "ok"},
{ OP_Callback, 1, 0, 0},
};
/* Initialize the VDBE program */
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
sqlite3VdbeSetNumCols(v, 1);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P3_STATIC);
sqlite3VdbeAddOp(v, OP_MemInt, 0, 0); /* Initialize error count to 0 */
/* Do an integrity check on each database file */
for(i=0; i<db->nDb; i++){
HashElem *x;
Hash *pTbls;
int cnt = 0;
if( OMIT_TEMPDB && i==1 ) continue;
sqlite3CodeVerifySchema(pParse, i);
/* Do an integrity check of the B-Tree
*/
pTbls = &db->aDb[i].pSchema->tblHash;
for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
Table *pTab = sqliteHashData(x);
Index *pIdx;
sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0);
cnt++;
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0);
cnt++;
}
}
assert( cnt>0 );
sqlite3VdbeAddOp(v, OP_IntegrityCk, cnt, i);
sqlite3VdbeAddOp(v, OP_Dup, 0, 1);
addr = sqlite3VdbeOp3(v, OP_String8, 0, 0, "ok", P3_STATIC);
sqlite3VdbeAddOp(v, OP_Eq, 0, addr+7);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName),
P3_DYNAMIC);
sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
sqlite3VdbeAddOp(v, OP_Concat, 0, 1);
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
sqlite3VdbeAddOp(v, OP_MemIncr, 1, 0);
/* Make sure all the indices are constructed correctly.
*/
sqlite3CodeVerifySchema(pParse, i);
for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
Table *pTab = sqliteHashData(x);
Index *pIdx;
int loopTop;
if( pTab->pIndex==0 ) continue;
sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
sqlite3VdbeAddOp(v, OP_MemInt, 0, 1);
loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0);
sqlite3VdbeAddOp(v, OP_MemIncr, 1, 1);
for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
int jmp2;
static const VdbeOpList idxErr[] = {
{ OP_MemIncr, 1, 0, 0},
{ OP_String8, 0, 0, "rowid "},
{ OP_Rowid, 1, 0, 0},
{ OP_String8, 0, 0, " missing from index "},
{ OP_String8, 0, 0, 0}, /* 4 */
{ OP_Concat, 2, 0, 0},
{ OP_Callback, 1, 0, 0},
};
sqlite3GenerateIndexKey(v, pIdx, 1);
jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0);
addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC);
sqlite3VdbeJumpHere(v, jmp2);
}
sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1);
sqlite3VdbeJumpHere(v, loopTop);
for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
static const VdbeOpList cntIdx[] = {
{ OP_MemInt, 0, 2, 0},
{ OP_Rewind, 0, 0, 0}, /* 1 */
{ OP_MemIncr, 1, 2, 0},
{ OP_Next, 0, 0, 0}, /* 3 */
{ OP_MemLoad, 1, 0, 0},
{ OP_MemLoad, 2, 0, 0},
{ OP_Eq, 0, 0, 0}, /* 6 */
{ OP_MemIncr, 1, 0, 0},
{ OP_String8, 0, 0, "wrong # of entries in index "},
{ OP_String8, 0, 0, 0}, /* 9 */
{ OP_Concat, 0, 0, 0},
{ OP_Callback, 1, 0, 0},
};
if( pIdx->tnum==0 ) continue;
addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
sqlite3VdbeChangeP1(v, addr+1, j+2);
sqlite3VdbeChangeP2(v, addr+1, addr+4);
sqlite3VdbeChangeP1(v, addr+3, j+2);
sqlite3VdbeChangeP2(v, addr+3, addr+2);
sqlite3VdbeJumpHere(v, addr+6);
sqlite3VdbeChangeP3(v, addr+9, pIdx->zName, P3_STATIC);
}
}
}
addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
sqlite3VdbeJumpHere(v, addr+2);
}else
#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
#ifndef SQLITE_OMIT_UTF16
/*
** PRAGMA encoding
** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
**
** In it's first form, this pragma returns the encoding of the main
** database. If the database is not initialized, it is initialized now.
**
** The second form of this pragma is a no-op if the main database file
** has not already been initialized. In this case it sets the default
** encoding that will be used for the main database file if a new file
** is created. If an existing main database file is opened, then the
** default text encoding for the existing database is used.
**
** In all cases new databases created using the ATTACH command are
** created to use the same default text encoding as the main database. If
** the main database has not been initialized and/or created when ATTACH
** is executed, this is done before the ATTACH operation.
**
** In the second form this pragma sets the text encoding to be used in
** new database files created using this database handle. It is only
** useful if invoked immediately after the main database i
*/
if( sqlite3StrICmp(zLeft, "encoding")==0 ){
static struct EncName {
char *zName;
u8 enc;
} encnames[] = {
{ "UTF-8", SQLITE_UTF8 },
{ "UTF8", SQLITE_UTF8 },
{ "UTF-16le", SQLITE_UTF16LE },
{ "UTF16le", SQLITE_UTF16LE },
{ "UTF-16be", SQLITE_UTF16BE },
{ "UTF16be", SQLITE_UTF16BE },
{ "UTF-16", 0 /* Filled in at run-time */ },
{ "UTF16", 0 /* Filled in at run-time */ },
{ 0, 0 }
};
struct EncName *pEnc;
encnames[6].enc = encnames[7].enc = SQLITE_UTF16NATIVE;
if( !zRight ){ /* "PRAGMA encoding" */
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
sqlite3VdbeSetNumCols(v, 1);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P3_STATIC);
sqlite3VdbeAddOp(v, OP_String8, 0, 0);
for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
if( pEnc->enc==ENC(pParse->db) ){
sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC);
break;
}
}
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
}else{ /* "PRAGMA encoding = XXX" */
/* Only change the value of sqlite.enc if the database handle is not
** initialized. If the main database exists, the new sqlite.enc value
** will be overwritten when the schema is next loaded. If it does not
** already exists, it will be created to use the new encoding value.
*/
if(
!(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
DbHasProperty(db, 0, DB_Empty)
){
for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
ENC(pParse->db) = pEnc->enc;
break;
}
}
if( !pEnc->zName ){
sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
}
}
}
}else
#endif /* SQLITE_OMIT_UTF16 */
#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
/*
** PRAGMA [database.]schema_version
** PRAGMA [database.]schema_version = <integer>
**
** PRAGMA [database.]user_version
** PRAGMA [database.]user_version = <integer>
**
** The pragma's schema_version and user_version are used to set or get
** the value of the schema-version and user-version, respectively. Both
** the schema-version and the user-version are 32-bit signed integers
** stored in the database header.
**
** The schema-cookie is usually only manipulated internally by SQLite. It
** is incremented by SQLite whenever the database schema is modified (by
** creating or dropping a table or index). The schema version is used by
** SQLite each time a query is executed to ensure that the internal cache
** of the schema used when compiling the SQL query matches the schema of
** the database against which the compiled query is actually executed.
** Subverting this mechanism by using "PRAGMA schema_version" to modify
** the schema-version is potentially dangerous and may lead to program
** crashes or database corruption. Use with caution!
**
** The user-version is not used internally by SQLite. It may be used by
** applications for any purpose.
*/
if( sqlite3StrICmp(zLeft, "schema_version")==0 ||
sqlite3StrICmp(zLeft, "user_version")==0 ){
int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
if( zLeft[0]=='s' || zLeft[0]=='S' ){
iCookie = 0;
}else{
iCookie = 5;
}
if( zRight ){
/* Write the specified cookie value */
static const VdbeOpList setCookie[] = {
{ OP_Transaction, 0, 1, 0}, /* 0 */
{ OP_Integer, 0, 0, 0}, /* 1 */
{ OP_SetCookie, 0, 0, 0}, /* 2 */
};
int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
sqlite3VdbeChangeP1(v, addr, iDb);
sqlite3VdbeChangeP1(v, addr+1, atoi(zRight));
sqlite3VdbeChangeP1(v, addr+2, iDb);
sqlite3VdbeChangeP2(v, addr+2, iCookie);
}else{
/* Read the specified cookie value */
static const VdbeOpList readCookie[] = {
{ OP_ReadCookie, 0, 0, 0}, /* 0 */
{ OP_Callback, 1, 0, 0}
};
int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
sqlite3VdbeChangeP1(v, addr, iDb);
sqlite3VdbeChangeP2(v, addr, iCookie);
sqlite3VdbeSetNumCols(v, 1);
}
}
#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
/*
** Report the current state of file logs for all databases
*/
if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
static const char *const azLockName[] = {
"unlocked", "shared", "reserved", "pending", "exclusive"
};
int i;
Vdbe *v = sqlite3GetVdbe(pParse);
sqlite3VdbeSetNumCols(v, 2);
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P3_STATIC);
sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P3_STATIC);
for(i=0; i<db->nDb; i++){
Btree *pBt;
Pager *pPager;
if( db->aDb[i].zName==0 ) continue;
sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, P3_STATIC);
pBt = db->aDb[i].pBt;
if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
sqlite3VdbeOp3(v, OP_String8, 0, 0, "closed", P3_STATIC);
}else{
int j = sqlite3pager_lockstate(pPager);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
(j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC);
}
sqlite3VdbeAddOp(v, OP_Callback, 2, 0);
}
}else
#endif
#ifdef SQLITE_SSE
/*
** Check to see if the sqlite_statements table exists. Create it
** if it does not.
*/
if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){
extern int sqlite3CreateStatementsTable(Parse*);
sqlite3CreateStatementsTable(pParse);
}else
#endif
#if SQLITE_HAS_CODEC
if( sqlite3StrICmp(zLeft, "key")==0 ){
sqlite3_key(db, zRight, strlen(zRight));
}else
#endif
{}
if( v ){
/* Code an OP_Expire at the end of each PRAGMA program to cause
** the VDBE implementing the pragma to expire. Most (all?) pragmas
** are only valid for a single execution.
*/
sqlite3VdbeAddOp(v, OP_Expire, 1, 0);
/*
** Reset the safety level, in case the fullfsync flag or synchronous
** setting changed.
*/
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
if( db->autoCommit ){
sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
(db->flags&SQLITE_FullFSync)!=0);
}
#endif
}
pragma_out:
sqliteFree(zLeft);
sqliteFree(zRight);
}
gui_window_styles WndStyle = GUI_PLAIN+GUI_GMOUSE;
char *WndGadgetHint[] =
{
"this is help for the folder",
"this is help for the stop sign"
};
gui_resource WndGadgetArray[] = {
{ BITMAP_SOURCE1, "[f]"},
{ BITMAP_STOP1, "[X]"},
{ BITMAP_SOURCE2, "|f|"},
{ BITMAP_STOP2, "|X|"},
};
int WndGadgetArraySize = ArraySize( WndGadgetArray );
int WndGadgetSecondary = 2;
wnd_attr WndGadgetAttr = APP_COLOR_HOTSPOT;
static gui_colour_set WndDlgColours[] = {
{ GUI_WHITE, GUI_BLUE }, // GUI_DLG_NORMAL
{ GUI_BLUE, GUI_CYAN }, // GUI_DLG_FRAME
{ GUI_BLACK, GUI_BLUE }, // GUI_DLG_SHADOW
{ GUI_WHITE, GUI_BLUE }, // GUI_DLG_SCROLL_ICON
{ GUI_WHITE, GUI_BLUE }, // GUI_DLG_SCROLL_BAR
{ GUI_BLUE, GUI_WHITE }, // GUI_DLG_BUTTON_PLAIN
{ GUI_BRIGHT_WHITE, GUI_WHITE }, // GUI_DLG_BUTTON_STANDOUT
{ GUI_BLUE, GUI_CYAN }, // GUI_DLG_BUTTON_ACTIVE
{ GUI_BRIGHT_WHITE, GUI_CYAN }, // GUI_DLG_BUTTON_ACTIVE_STANDOUT
};
wxBoxSizer* TASInputDlg::CreateCCLayout()
{
wxBoxSizer* const szr = new wxBoxSizer(wxHORIZONTAL);
for (size_t i = 0; i < ArraySize(m_cc_buttons); ++i)
m_cc_buttons[i] = CreateButton(m_cc_button_names[i]);
m_cc_l_stick = CreateStick(ID_CC_L_STICK, 63, 63, WiimoteEmu::Classic::LEFT_STICK_CENTER_X, WiimoteEmu::Classic::LEFT_STICK_CENTER_Y, false, true);
m_cc_r_stick = CreateStick(ID_CC_R_STICK, 31, 31, WiimoteEmu::Classic::RIGHT_STICK_CENTER_X, WiimoteEmu::Classic::RIGHT_STICK_CENTER_Y, false, true);
m_cc_controls[CC_L_STICK_X] = &m_cc_l_stick.x_cont;
m_cc_controls[CC_L_STICK_Y] = &m_cc_l_stick.y_cont;
m_cc_controls[CC_R_STICK_X] = &m_cc_r_stick.x_cont;
m_cc_controls[CC_R_STICK_Y] = &m_cc_r_stick.y_cont;
m_cc_controls[CC_L_TRIGGER] = &m_cc_l;
m_cc_controls[CC_R_TRIGGER] = &m_cc_r;
m_cc_l_stick_szr = CreateStickLayout(&m_cc_l_stick, _("Left stick"));
m_cc_r_stick_szr = CreateStickLayout(&m_cc_r_stick, _("Right stick"));
m_cc_l = CreateControl(wxSL_VERTICAL, -1, 100, false, 31, 0);;
m_cc_r = CreateControl(wxSL_VERTICAL, -1, 100, false, 31, 0);;
wxStaticBoxSizer* const shoulder_box = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Shoulder Buttons"));
shoulder_box->Add(m_cc_l.slider, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_cc_l.text, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_cc_r.slider, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_cc_r.text, 0, wxALIGN_CENTER_VERTICAL);
wxStaticBoxSizer* const cc_buttons_box = new wxStaticBoxSizer(wxVERTICAL, this, _("Buttons"));
wxGridSizer* const cc_buttons_grid = new wxGridSizer(4);
wxGridSizer* const cc_buttons_dpad = new wxGridSizer(3);
cc_buttons_dpad->AddSpacer(20);
cc_buttons_dpad->Add(m_cc_buttons[1].checkbox);
cc_buttons_dpad->AddSpacer(20);
cc_buttons_dpad->Add(m_cc_buttons[2].checkbox);
cc_buttons_dpad->AddSpacer(20);
cc_buttons_dpad->Add(m_cc_buttons[3].checkbox);
cc_buttons_dpad->AddSpacer(20);
cc_buttons_dpad->Add(m_cc_buttons[0].checkbox);
cc_buttons_dpad->AddSpacer(20);
for (auto button : m_cc_buttons)
cc_buttons_grid->Add(button.checkbox);
cc_buttons_grid->AddSpacer(5);
cc_buttons_box->Add(cc_buttons_grid);
cc_buttons_box->Add(cc_buttons_dpad);
szr->Add(m_cc_l_stick_szr, 0, wxALL, 5);
szr->Add(m_cc_r_stick_szr, 0, wxALL, 5);
szr->Add(shoulder_box, 0, wxLEFT | wxRIGHT, 5);
szr->Add(cc_buttons_box, 0, wxTOP | wxRIGHT, 5);
for (Control* const control : m_cc_controls)
{
if (control != nullptr)
control->slider->Bind(wxEVT_RIGHT_UP, &TASInputDlg::OnRightClickSlider, this);
}
return szr;
}
#include "hdb.h"
char *functionStrings[] = {
/* From snpFixed.SnpFunctionCode. */
"unknown",
"locus",
"coding", // not used
"coding-synon",
"coding-nonsynon",
"untranslated",
"intron",
"splice-site",
// "cds-reference", not useful
};
boolean functionFound[ArraySize(functionStrings)];
static char const rcsid[] = "$Id: snpContigLocusIdCondense.c,v 1.9 2006/12/05 17:59:28 heather Exp $";
static char *snpDb = NULL;
void usage()
/* Explain usage and exit. */
{
errAbort(
"snpContigLocusIdCondense - condense the ContigLocusIdFilter table to contain one row per snp_id\n"
"usage:\n"
" snpContigLocusIdCondense snpDb\n");
}
void initArray()
void TASInputDlg::CreateGCLayout()
{
if (m_has_layout)
return;
CreateBaseLayout();
m_buttons[6] = &m_x;
m_buttons[7] = &m_y;
m_buttons[8] = &m_z;
m_buttons[9] = &m_l;
m_buttons[10] = &m_r;
m_buttons[11] = &m_start;
m_controls[2] = &m_c_stick.x_cont;
m_controls[3] = &m_c_stick.y_cont;
m_controls[4] = &m_l_cont;
m_controls[5] = &m_r_cont;
wxBoxSizer* const top_box = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* const bottom_box = new wxBoxSizer(wxHORIZONTAL);
m_main_stick = CreateStick(ID_MAIN_STICK, 255, 255, 128, 128, false, true);
wxStaticBoxSizer* const main_box = CreateStickLayout(&m_main_stick, _("Main Stick"));
m_c_stick = CreateStick(ID_C_STICK, 255, 255, 128, 128, false, true);
wxStaticBoxSizer* const c_box = CreateStickLayout(&m_c_stick, _("C Stick"));
wxStaticBoxSizer* const shoulder_box = new wxStaticBoxSizer(wxHORIZONTAL, this, _("Shoulder Buttons"));
m_l_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 255, 0);
m_r_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 255, 0);
shoulder_box->Add(m_l_cont.slider, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_l_cont.text, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_r_cont.slider, 0, wxALIGN_CENTER_VERTICAL);
shoulder_box->Add(m_r_cont.text, 0, wxALIGN_CENTER_VERTICAL);
for (Control* const control : m_controls)
{
if (control != nullptr)
control->slider->Bind(wxEVT_RIGHT_UP, &TASInputDlg::OnRightClickSlider, this);
}
wxStaticBoxSizer* const m_buttons_box = new wxStaticBoxSizer(wxVERTICAL, this, _("Buttons"));
wxGridSizer* const m_buttons_grid = new wxGridSizer(4);
m_x = CreateButton("X");
m_y = CreateButton("Y");
m_l = CreateButton("L");
m_r = CreateButton("R");
m_z = CreateButton("Z");
m_start = CreateButton("Start");
for (unsigned int i = 4; i < ArraySize(m_buttons); ++i)
if (m_buttons[i] != nullptr)
m_buttons_grid->Add(m_buttons[i]->checkbox, false);
m_buttons_grid->AddSpacer(5);
m_buttons_box->Add(m_buttons_grid);
m_buttons_box->Add(m_buttons_dpad);
wxBoxSizer* const main_szr = new wxBoxSizer(wxVERTICAL);
top_box->Add(main_box, 0, wxALL, 5);
top_box->Add(c_box, 0, wxTOP | wxRIGHT, 5);
bottom_box->Add(shoulder_box, 0, wxLEFT | wxRIGHT, 5);
bottom_box->Add(m_buttons_box, 0, wxBOTTOM, 5);
main_szr->Add(top_box);
main_szr->Add(bottom_box);
SetSizerAndFit(main_szr);
ResetValues();
m_has_layout = true;
}
/*
** Return the N-th compile-time option string. If N is out of range,
** return a NULL pointer.
*/
const char *sqlite3_compileoption_get(int N){
if( N>=0 && N<ArraySize(azCompileOpt) ){
return azCompileOpt[N];
}
return 0;
}
void TASInputDlg::CreateWiiLayout(int num)
{
if (m_has_layout)
return;
CreateBaseLayout();
m_buttons[6] = &m_one;
m_buttons[7] = &m_two;
m_buttons[8] = &m_plus;
m_buttons[9] = &m_minus;
m_buttons[10] = &m_home;
m_controls[4] = &m_x_cont;
m_controls[5] = &m_y_cont;
m_controls[6] = &m_z_cont;
m_main_stick = CreateStick(ID_MAIN_STICK, 1024, 768, 512, 384, true, false);
m_main_stick_szr = CreateStickLayout(&m_main_stick, _("IR"));
m_x_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 512);
m_y_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 512);
m_z_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 616);
wxStaticBoxSizer* const axisBox = CreateAccelLayout(&m_x_cont, &m_y_cont, &m_z_cont, _("Orientation"));
wxStaticBoxSizer* const m_buttons_box = new wxStaticBoxSizer(wxVERTICAL, this, _("Buttons"));
wxGridSizer* const m_buttons_grid = new wxGridSizer(4);
m_plus = CreateButton("+");
m_minus = CreateButton("-");
m_one = CreateButton("1");
m_two = CreateButton("2");
m_home = CreateButton("Home");
m_main_szr = new wxBoxSizer(wxVERTICAL);
m_wiimote_szr = new wxBoxSizer(wxHORIZONTAL);
m_ext_szr = new wxBoxSizer(wxHORIZONTAL);
m_cc_szr = CreateCCLayout();
if (Core::IsRunning())
{
m_ext = ((WiimoteEmu::Wiimote*)Wiimote::GetConfig()->controllers[num])->CurrentExtension();
}
else
{
IniFile ini;
ini.Load(File::GetUserPath(D_CONFIG_IDX) + "WiimoteNew.ini");
std::string extension;
ini.GetIfExists("Wiimote" + std::to_string(num + 1), "Extension", &extension);
if (extension == "Nunchuk")
m_ext = 1;
if (extension == "Classic")
m_ext = 2;
}
m_buttons[11] = &m_c;
m_buttons[12] = &m_z;
m_controls[2] = &m_c_stick.x_cont;
m_controls[3] = &m_c_stick.y_cont;
m_controls[7] = &m_nx_cont;
m_controls[8] = &m_ny_cont;
m_controls[9] = &m_nz_cont;
m_c_stick = CreateStick(ID_C_STICK, 255, 255, 128, 128, false, true);
m_c_stick_szr = CreateStickLayout(&m_c_stick, _("Nunchuk stick"));
m_nx_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 512);
m_ny_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 512);
m_nz_cont = CreateControl(wxSL_VERTICAL, -1, 100, false, 1023, 512);
wxStaticBoxSizer* const nunchukaxisBox = CreateAccelLayout(&m_nx_cont, &m_ny_cont, &m_nz_cont, _("Nunchuk orientation"));
m_c = CreateButton("C");
m_z = CreateButton("Z");
m_ext_szr->Add(m_c_stick_szr, 0, wxLEFT | wxBOTTOM | wxRIGHT, 5);
m_ext_szr->Add(nunchukaxisBox);
for (Control* const control : m_controls)
{
if (control != nullptr)
control->slider->Bind(wxEVT_RIGHT_UP, &TASInputDlg::OnRightClickSlider, this);
}
for (unsigned int i = 4; i < ArraySize(m_buttons); ++i)
if (m_buttons[i] != nullptr)
m_buttons_grid->Add(m_buttons[i]->checkbox);
m_buttons_grid->AddSpacer(5);
m_buttons_box->Add(m_buttons_grid);
m_buttons_box->Add(m_buttons_dpad);
m_wiimote_szr->Add(m_main_stick_szr, 0, wxALL, 5);
m_wiimote_szr->Add(axisBox, 0, wxTOP | wxRIGHT, 5);
m_wiimote_szr->Add(m_buttons_box, 0, wxTOP | wxRIGHT, 5);
m_main_szr->Add(m_wiimote_szr);
m_main_szr->Add(m_ext_szr);
m_main_szr->Add(m_cc_szr);
HandleExtensionChange();
m_has_layout = true;
}
void DL_Jww::CreateEnko(DL_CreationInterface* creationInterface, CDataEnko& DEnko)
{
string lName = HEX[DEnko.m_nGLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DEnko.m_nGLayer] + "-" +
HEX[DEnko.m_nLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DEnko.m_nLayer];
// add layer
creationInterface->addLayer(DL_LayerData(lName,0));
int width;
if(DEnko.m_nPenWidth > 26)
width = 0;
else
width = DEnko.m_nPenWidth;
int color = colTable[DEnko.m_nPenColor > ArraySize(colTable)-1 ? ArraySize(colTable)-1 : DEnko.m_nPenColor];
attrib = DL_Attributes(values[8], // layer
color, // color
width, // width
lTable[DEnko.m_nPenStyle > ArraySize(lTable)-1 ? ArraySize(lTable)-1 : DEnko.m_nPenStyle]); // linetype
creationInterface->setAttributes(attrib);
creationInterface->setExtrusion(0.0, 0.0, 1.0, 0.0 );
double angle1, angle2;
//正円
if(DEnko.m_bZenEnFlg){
if(DEnko.m_dHenpeiRitsu == 1.0){
DL_CircleData d(DEnko.m_start.x, DEnko.m_start.y, 0.0, DEnko.m_dHankei);
creationInterface->addCircle(d);
}else{
double angle1, angle2;
if(DEnko.m_radEnkoKaku > 0.0){
angle1 = DEnko.m_radKaishiKaku;
angle2 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
}else{
angle1 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
angle2 = DEnko.m_radKaishiKaku;
}
angle1 = angle1 - floor(angle1 / (M_PI * 2.0)) * M_PI * 2.0;
angle2 = angle2 - floor(angle2 / (M_PI * 2.0)) * M_PI * 2.0;
if( angle2 <= angle1 )
angle1 = angle1 - M_PI * 2.0;
//楕円
DL_EllipseData d(DEnko.m_start.x, DEnko.m_start.y, 0.0,
DEnko.m_dHankei * cos(DEnko.m_radKatamukiKaku), DEnko.m_dHankei * sin(DEnko.m_radKatamukiKaku), 0.0,
DEnko.m_dHenpeiRitsu,
angle1, angle2);
creationInterface->addEllipse(d);
}
}else{
if(DEnko.m_dHenpeiRitsu == 1.0){
//円弧
if(DEnko.m_radEnkoKaku > 0.0){
angle1 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku;
angle2 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku + DEnko.m_radEnkoKaku;
}else{
angle1 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku + DEnko.m_radEnkoKaku;
angle2 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku;
}
angle1 = angle1 - floor(angle1 / (M_PI * 2.0)) * M_PI * 2.0;
angle2 = angle2 - floor(angle2 / (M_PI * 2.0)) * M_PI * 2.0;
if( angle2 <= angle1 )
angle1 = angle1 - M_PI * 2.0;
DL_ArcData d(DEnko.m_start.x, DEnko.m_start.y, 0.0,
DEnko.m_dHankei,
Deg(angle1),
Deg(angle2));
creationInterface->addArc(d);
}else{
double angle1, angle2;
if(DEnko.m_radEnkoKaku > 0.0){
angle1 = DEnko.m_radKaishiKaku;
angle2 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
}else{
angle1 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
angle2 = DEnko.m_radKaishiKaku;
}
angle1 = angle1 - floor(angle1 / (M_PI * 2.0)) * M_PI * 2.0;
angle2 = angle2 - floor(angle2 / (M_PI * 2.0)) * M_PI * 2.0;
if( angle2 <= angle1 )
angle1 = angle1 - M_PI * 2.0;
//楕円
DL_EllipseData d(DEnko.m_start.x, DEnko.m_start.y, 0.0,
DEnko.m_dHankei * cos(DEnko.m_radKatamukiKaku), DEnko.m_dHankei * sin(DEnko.m_radKatamukiKaku), 0.0,
DEnko.m_dHenpeiRitsu,
angle1, angle2);
creationInterface->addEllipse(d);
}
}
#ifdef FINISHED
RS_CircleData data1(RS_Vector(0.0, 0.0), 0.0);
RS_Circle* circle;
RS_ArcData arc_data(RS_Vector(0.0, 0.0), 0.0, 0.0, 0.0, false);
RS_Arc* arc;
RS_Ellipse* elps;
//正円
if(DEnko.m_bZenEnFlg){
if(DEnko.m_dHenpeiRitsu == 1.0){
data1.center = RS_Vector(DEnko.m_start.x, DEnko.m_start.y);
data1.radius = DEnko.m_dHankei;
circle = new RS_Circle(graphic, data1);
RS2::LineType ltype = lTable[DEnko.m_nPenStyle];
RS_Color col = colTable[DEnko.m_nPenColor];
RS2::LineWidth lw = lWidth[DEnko.m_nPenWidth > 26 ? 0 : DEnko.m_nPenWidth];//RS2::Width12
circle->setPen(RS_Pen(col, lw, ltype));
RS_String lName = HEX[DEnko.m_nGLayer > 0x0f ? 0:DEnko.m_nGLayer] + "-" +
HEX[DEnko.m_nLayer > 0x0f ? 0: DEnko.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
#ifdef DEBUG
std::cout << lName.ascii() << std::endl;
#endif
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
circle->setLayer(lName);
// add the line to the graphic
graphic->addEntity(circle);
#ifdef DEBUG
std::cout << *circle;
#endif
}else{
//楕円
double angle1, angle2;
if(DEnko.m_radEnkoKaku > 0.0){
angle1 = DEnko.m_radKaishiKaku;
angle2 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
}else{
angle1 = DEnko.m_radKaishiKaku + DEnko.m_radEnkoKaku;
angle2 = DEnko.m_radKaishiKaku;
}
angle1 = angle1 - floor(angle1 / (M_PI * 2.0)) * M_PI * 2.0;
angle2 = angle2 - floor(angle2 / (M_PI * 2.0)) * M_PI * 2.0;
if( angle2 <= angle1 )
angle1 = angle1 - M_PI * 2.0;
RS_EllipseData elps_data(RS_Vector(DEnko.m_start.x, DEnko.m_start.y),
RS_Vector(DEnko.m_dHankei * cos(DEnko.m_radKatamukiKaku), DEnko.m_dHankei * sin(DEnko.m_radKatamukiKaku)),
DEnko.m_dHenpeiRitsu,
angle1, angle2, false);
elps = new RS_Ellipse(graphic, elps_data);
RS2::LineType ltype = lTable[DEnko.m_nPenStyle];
RS_Color col = colTable[DEnko.m_nPenColor];
RS2::LineWidth lw = lWidth[DEnko.m_nPenWidth > 26 ? 0 : DEnko.m_nPenWidth];//RS2::Width12
elps->setPen(RS_Pen(col, lw, ltype));
RS_String lName = HEX[DEnko.m_nGLayer > 0x0f ? 0:DEnko.m_nGLayer] + "-" +
HEX[DEnko.m_nLayer > 0x0f ? 0: DEnko.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
elps->setLayer(lName);
// add the line to the graphic
graphic->addEntity(elps);
}
}else{
//円弧
arc_data.center = RS_Vector(DEnko.m_start.x, DEnko.m_start.y);
arc_data.radius = DEnko.m_dHankei;
if(DEnko.m_radEnkoKaku > 0.0){
arc_data.angle1 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku;
arc_data.angle2 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku + DEnko.m_radEnkoKaku;
}else{
arc_data.angle1 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku + DEnko.m_radEnkoKaku;
arc_data.angle2 = DEnko.m_radKaishiKaku + DEnko.m_radKatamukiKaku;
}
if( arc_data.angle2 <= arc_data.angle1 )
arc_data.angle1 = arc_data.angle1 - M_PI * 2.0;
arc_data.angle1 = Deg(arc_data.angle1);
arc_data.angle2 = Deg(arc_data.angle2);
arc_data.reversed = false;
arc = new RS_Arc(graphic, arc_data);
RS2::LineType ltype = lTable[DEnko.m_nPenStyle];
RS_Color col = colTable[DEnko.m_nPenColor];
RS2::LineWidth lw = lWidth[DEnko.m_nPenWidth > 26 ? 0 : DEnko.m_nPenWidth];//RS2::Width12
arc->setPen(RS_Pen(col, lw, ltype));
RS_String lName = HEX[DEnko.m_nGLayer > 0x0f ? 0:DEnko.m_nGLayer] + "-" +
HEX[DEnko.m_nLayer > 0x0f ? 0: DEnko.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
#ifdef DEBUG
std::cout << lName.ascii() << std::endl;
#endif
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
arc->setLayer(lName);
// add the line to the graphic
graphic->addEntity(arc);
}
#endif
}
void addFile(char *fileName)
/* Add all the words in file to database. */
{
struct lineFile *lf = lineFileOpen(fileName, FALSE);
char *line;
int lineSize;
char wordBuf[1024];
int lineBuf[512];
int highestWordId = 0;
int wordCount;
char *nullPt = NULL;
struct hash *wordHash = newHash(16);
struct hashEl *hel;
struct dyString *query = newDyString(512);
struct sqlConnection *conn = sqlConnect(database);
int i;
int lineCount = 0;
while (lineFileNext(lf, &line, &lineSize))
{
/* Chop the line up into words. */
int wordCount = 0;
int startWord;
int wordSize;
int sizeLeft;
int wordId;
int i;
for (sizeLeft = lineSize; sizeLeft > 0; sizeLeft -= wordSize, line += wordSize)
{
wordSize = tokSize(line, sizeLeft);
if (wordSize >= sizeof(wordBuf))
errAbort("Word too long line %d of %s", lf->lineIx, lf->fileName);
memcpy(wordBuf, line, wordSize);
wordBuf[wordSize] = 0;
if (wordBuf[wordSize-1] == ' ')
wordBuf[wordSize-1] = '_';
if ((hel = hashLookup(wordHash, wordBuf)) == NULL)
{
wordId = highestWordId++;
hel = hashAdd(wordHash, wordBuf, nullPt + wordId);
dyStringClear(query);
if (wordBuf[0] == '\'')
{
dyStringPrintf(query,
"INSERT into word values (%d, \"'\")", wordId);
}
else if (wordBuf[0] == '\\')
{
dyStringPrintf(query,
"INSERT into word values (%d, '\\\\')", wordId);
}
else
{
dyStringPrintf(query,
"INSERT into word values (%d, '%s')", wordId, wordBuf);
}
sqlGetResult(conn, query->string);
}
else
{
wordId = (char *)(hel->val) - nullPt;
}
if (wordCount >= ArraySize(lineBuf))
{
errAbort("Too many words in line %d of %s", lf->lineIx, lf->fileName);
}
lineBuf[wordCount++] = wordId;
}
/* Store the words in the database */
dyStringClear(query);
dyStringPrintf(query,
"INSERT into commaLine values (%d, %d, '", lineCount, wordCount);
for (i=0; i<wordCount; ++i)
dyStringPrintf(query, "%d,", lineBuf[i]);
dyStringAppend(query, "')");
sqlGetResult(conn, query->string);
dyStringClear(query);
dyStringPrintf(query,
"INSERT into lineSize values (%d,%d)", lineCount, wordCount);
sqlGetResult(conn, query->string);
for (i=0; i<wordCount; ++i)
{
dyStringClear(query);
dyStringPrintf(query,
"INSERT into lineWords values (%d,%d,%d)", lineCount, lineBuf[i], i);
sqlGetResult(conn, query->string);
}
++lineCount;
}
sqlDisconnect(&conn);
}
void encodeExpToTab(char *outExp, char *outSeries, char *outResults)
/* encodeExpToCvDb - Convert encode experiments table to a table more suitable for cvDb. */
{
struct hash *optHash = optionalFieldsHash();
struct mdbObj *mdbList = getMdbList(metaDbs, ArraySize(metaDbs));
struct hash *mdbHash = mdbHashKeyedByExpId(mdbList);
struct hash *seriesHash = hashNew(0);
struct series *seriesList = NULL;
verbose(1, "read %d mdb objects from %s in %d databases\n", mdbHash->elCount, metaTable,
(int)ArraySize(metaDbs));
struct sqlConnection *expDbConn = sqlConnect(expDb);
struct sqlConnection *cvDbConn = sqlConnect(cvDb);
char query[256];
sqlSafef(query, sizeof(query), "select * from %s", expTable);
struct sqlResult *sr = sqlGetResult(expDbConn, query);
FILE *f = mustOpen(outExp, "w");
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
/* Read in database structure. */
struct encodeExp *ee = encodeExpLoad(row);
/* Much of the data we're processing comes from lists of the form
* "a=aVal b=bVal c=cVal." We'll convert these to id's in the appropriate
* tables and store the IDs in the optCol array declared below. */
int optColCount = ArraySize(expOptionalFields);
int optCol[optColCount];
int i;
for (i=0; i<optColCount; ++i)
optCol[i] = 0;
/* Convert var=val string in encodeExp.expVars into list of slPairs, and loop through it. */
struct slPair *varList = slPairListFromString(ee->expVars, TRUE);
struct slPair *var;
for (var = varList; var != NULL; var = var->next)
{
/* Figure out name of table and the term within that table. */
char *table = var->name;
char *term = var->val;
if (sameString(table, "antibody")) // Deal with antibody special case
{
if (sameString(term, "Control") || sameString(term, "Input")
|| sameString(term, "RevXlinkChromatin") || sameString(term, "ripInput"))
{
table = "control";
}
}
/* If it looks like we have a valid table and term, store result in
* optCol array we'll output soon. */
struct hashEl *hel;
if ((hel = hashLookup(optHash, table)) != NULL)
{
int id = lookupId(cvDbConn, table, term);
if (id == 0)
{
warn("No id in cvDb for %s=%s\n", table, term);
continue;
}
int optColIx = ptToInt(hel->val);
optCol[optColIx] = id;
}
else
verbose(2, "%s %s ?\n", table, term);
}
/* Now we want to process metaDb, which has some info encodeExp does not. */
char *composite = NULL;
char ixAsString[16];
safef(ixAsString, sizeof(ixAsString), "%d", ee->ix);
struct mdbObj *mdb = hashFindVal(mdbHash, ixAsString);
if (mdb != NULL)
{
struct mdbVar *v;
for (v = mdb->vars; v != NULL; v = v->next)
{
/* Look up table and term and change table name if need be */
char *table = v->var;
char *term = v->val;
if (sameString(table, "antibody"))
table = "ab";
else if (sameString(table, "grant"))
table = "grantee";
/* Squirrel away the ever-important composite term for later. */
if (sameString("composite", table))
composite = term;
struct hashEl *hel;
if ((hel = hashLookup(optHash, table)) != NULL)
{
int optColIx = ptToInt(hel->val);
if (optCol[optColIx] == 0) // Only use mdb if encodeExp has no data.
{
int id = lookupId(cvDbConn, table, term);
optCol[optColIx] = id;
}
}
}
}
/* If we've got a composite, then make up a series record. */
if (composite != NULL)
{
assert(mdb != NULL);
struct series *series = hashFindVal(seriesHash, composite);
if (series == NULL)
{
series = seriesFromMdb(mdb, composite);
hashAdd(seriesHash, composite, series);
slAddHead(&seriesList, series);
}
}
if (ee->accession != NULL)
{
/* Write out required fields. Order of required fields
* here needs to follow order in expRequiredFields. */
fprintf(f, "%u", ee->ix);
fprintf(f, "\t%s", ee->updateTime);
fprintf(f, "\t%s", naForNull(composite));
fprintf(f, "\t%s", ee->accession);
fprintf(f, "\t%d", lookupId(cvDbConn, "organism", ee->organism));
fprintf(f, "\t%d", lookupId(cvDbConn, "lab", ee->lab));
fprintf(f, "\t%d", lookupId(cvDbConn, "dataType", ee->dataType));
fprintf(f, "\t%d", lookupId(cvDbConn, "cellType", ee->cellType));
/* Now write out optional fields. */
for (i=0; i<optColCount; ++i)
fprintf(f, "\t%d", optCol[i]);
/* End output record. */
fprintf(f, "\n");
}
}
/* Write out series list to a separate file. */
slReverse(&seriesList);
writeSeriesList(outSeries, seriesList);
/* Write out results to a separate file. */
writeMdbListAsResults(mdbList, outResults);
/* Clean up and go home. */
carefulClose(&f);
sqlFreeResult(&sr);
sqlDisconnect(&expDbConn);
sqlDisconnect(&cvDbConn);
}
void ShaderD3D::compileToHLSL(ShHandle compiler, const std::string &source)
{
int compileOptions = (SH_OBJECT_CODE | SH_VARIABLES);
// D3D11 Feature Level 9_3 and below do not support non-constant loop indexers in fragment
// shaders.
// Shader compilation will fail. To provide a better error message we can instruct the
// compiler to pre-validate.
if (mRenderer->getRendererLimitations().shadersRequireIndexedLoopValidation)
{
compileOptions |= SH_VALIDATE_LOOP_INDEXING;
}
std::string sourcePath;
#if !defined (ANGLE_ENABLE_WINDOWS_STORE)
if (gl::DebugAnnotationsActive())
{
sourcePath = getTempPath();
writeFile(sourcePath.c_str(), source.c_str(), source.length());
compileOptions |= SH_LINE_DIRECTIVES;
}
#endif
int result;
if (sourcePath.empty())
{
const char* sourceStrings[] =
{
source.c_str(),
};
result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions);
}
else
{
const char* sourceStrings[] =
{
sourcePath.c_str(),
source.c_str(),
};
result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions | SH_SOURCE_PATH);
}
mShaderVersion = ShGetShaderVersion(compiler);
if (result)
{
mTranslatedSource = ShGetObjectCode(compiler);
#ifdef _DEBUG
// Prefix hlsl shader with commented out glsl shader
// Useful in diagnostics tools like pix which capture the hlsl shaders
std::ostringstream hlslStream;
hlslStream << "// GLSL\n";
hlslStream << "//\n";
size_t curPos = 0;
while (curPos != std::string::npos)
{
size_t nextLine = source.find("\n", curPos);
size_t len = (nextLine == std::string::npos) ? std::string::npos : (nextLine - curPos + 1);
hlslStream << "// " << source.substr(curPos, len);
curPos = (nextLine == std::string::npos) ? std::string::npos : (nextLine + 1);
}
hlslStream << "\n\n";
hlslStream << mTranslatedSource;
mTranslatedSource = hlslStream.str();
#endif
mUniforms = *GetShaderVariables(ShGetUniforms(compiler));
for (size_t uniformIndex = 0; uniformIndex < mUniforms.size(); uniformIndex++)
{
const sh::Uniform &uniform = mUniforms[uniformIndex];
if (uniform.staticUse && !uniform.isBuiltIn())
{
unsigned int index = static_cast<unsigned int>(-1);
bool getUniformRegisterResult = ShGetUniformRegister(compiler, uniform.name, &index);
UNUSED_ASSERTION_VARIABLE(getUniformRegisterResult);
ASSERT(getUniformRegisterResult);
mUniformRegisterMap[uniform.name] = index;
}
}
mInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
for (size_t blockIndex = 0; blockIndex < mInterfaceBlocks.size(); blockIndex++)
{
const sh::InterfaceBlock &interfaceBlock = mInterfaceBlocks[blockIndex];
if (interfaceBlock.staticUse)
{
unsigned int index = static_cast<unsigned int>(-1);
bool blockRegisterResult = ShGetInterfaceBlockRegister(compiler, interfaceBlock.name, &index);
UNUSED_ASSERTION_VARIABLE(blockRegisterResult);
ASSERT(blockRegisterResult);
mInterfaceBlockRegisterMap[interfaceBlock.name] = index;
}
}
}
else
{
mInfoLog = ShGetInfoLog(compiler);
TRACE("\n%s", mInfoLog.c_str());
}
}
void WINAPI GetOpenPanelInfoW(struct OpenPanelInfo *opi)
{
static wchar_t PanelTitle[50];
CServiceManager* sm=(CServiceManager*)opi->hPanel;
opi->StructSize = sizeof(*opi);
opi->Flags = OPIF_ADDDOTS|OPIF_SHOWPRESERVECASE|OPIF_SHORTCUT;
opi->CurDir = NULL;
if(sm->GetType()==SERVICE_WIN32)
opi->CurDir = ServicesDirName;
else if(sm->GetType()==SERVICE_DRIVER)
opi->CurDir = DriversDirName;
wstring sComputer = g_Settings.sComputer.length() > 0 ? g_Settings.sComputer : GetComputerName();
FSF.snprintf(
PanelTitle,
ArraySize(PanelTitle)-1,
L"%s%s%s",sComputer.c_str(),opi->CurDir?L": ":L"",opi->CurDir?opi->CurDir:L"");
opi->PanelTitle=PanelTitle;
static PanelMode PanelModesArray[10];
memset(&PanelModesArray, 0, sizeof (PanelModesArray));
opi->PanelModesArray=PanelModesArray;
opi->PanelModesNumber=ArraySize(PanelModesArray);
if(sm->GetType()==0)
{
PanelModesArray[0].ColumnTypes=L"N";
PanelModesArray[0].ColumnWidths=L"0";
PanelModesArray[0].StatusColumnTypes=L"N";
PanelModesArray[0].StatusColumnWidths=L"0";
}
else
{
static const wchar_t* ColumnTitles[] = {NULL,L"Status",L"Startup"};
PanelModesArray[0].ColumnTypes=L"N,C0,C1";
PanelModesArray[0].ColumnWidths=L"0,8,8";
PanelModesArray[0].StatusColumnTypes=L"N";
PanelModesArray[0].StatusColumnWidths=L"0";
PanelModesArray[0].ColumnTitles=ColumnTitles;
}
opi->StartPanelMode = L'0';
static vector<KeyBarLabel> vKeyBars;
vKeyBars.clear();
KeyBarLabel kbl;
kbl.Text = kbl.LongText = L"Help";
kbl.Key.VirtualKeyCode = VK_F1;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"";
kbl.Key.VirtualKeyCode = VK_F2;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"View";
kbl.Key.VirtualKeyCode = VK_F3;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"Edit";
kbl.Key.VirtualKeyCode = VK_F4;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"Start";
kbl.Key.VirtualKeyCode = VK_F5;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"Comp";
kbl.Key.VirtualKeyCode = VK_F6;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"Pause";
kbl.Key.VirtualKeyCode = VK_F7;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"Stop";
kbl.Key.VirtualKeyCode = VK_F8;
kbl.Key.ControlKeyState = 0;
vKeyBars.push_back(kbl);
for (WORD i = VK_F1; i <= VK_F9; ++i)
{
kbl.Text = kbl.LongText = L"";
kbl.Key.VirtualKeyCode = i;
kbl.Key.ControlKeyState = LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"";
kbl.Key.VirtualKeyCode = i;
kbl.Key.ControlKeyState = RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED;
vKeyBars.push_back(kbl);
kbl.Text = kbl.LongText = L"";
kbl.Key.VirtualKeyCode = i;
kbl.Key.ControlKeyState = SHIFT_PRESSED;
vKeyBars.push_back(kbl);
}
static KeyBarTitles kb;
kb.Labels = const_cast<KeyBarLabel*>(&vKeyBars.front());
kb.CountLabels = vKeyBars.size();
opi->KeyBar = &kb;
}
/*
** Locate a user function given a name, a number of arguments and a flag
** indicating whether the function prefers UTF-16 over UTF-8. Return a
** pointer to the FuncDef structure that defines that function, or return
** NULL if the function does not exist.
**
** If the createFlag argument is true, then a new (blank) FuncDef
** structure is created and liked into the "db" structure if a
** no matching function previously existed. When createFlag is true
** and the nArg parameter is -1, then only a function that accepts
** any number of arguments will be returned.
**
** If createFlag is false and nArg is -1, then the first valid
** function found is returned. A function is valid if either xFunc
** or xStep is non-zero.
**
** If createFlag is false, then a function with the required name and
** number of arguments may be returned even if the eTextRep flag does not
** match that requested.
*/
FuncDef *sqlite3FindFunction(
sqlite3 *db, /* An open database */
const char *zName, /* Name of the function. Not null-terminated */
int nName, /* Number of characters in the name */
int nArg, /* Number of arguments. -1 means any number */
u8 enc, /* Preferred text encoding */
int createFlag /* Create new entry if true and does not otherwise exist */
){
FuncDef *p; /* Iterator variable */
FuncDef *pBest = 0; /* Best match found so far */
int bestScore = 0; /* Score of best match */
int h; /* Hash value */
assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
if( nArg<-1 ) nArg = -1;
h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
/* First search for a match amongst the application-defined functions.
*/
p = functionSearch(&db->aFunc, h, zName, nName);
while( p ){
int score = matchQuality(p, nArg, enc);
if( score>bestScore ){
pBest = p;
bestScore = score;
}
p = p->pNext;
}
/* If no match is found, search the built-in functions.
**
** Except, if createFlag is true, that means that we are trying to
** install a new function. Whatever FuncDef structure is returned will
** have fields overwritten with new information appropriate for the
** new function. But the FuncDefs for built-in functions are read-only.
** So we must not search for built-ins when creating a new function.
*/
if( !createFlag && !pBest ){
FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
p = functionSearch(pHash, h, zName, nName);
while( p ){
int score = matchQuality(p, nArg, enc);
if( score>bestScore ){
pBest = p;
bestScore = score;
}
p = p->pNext;
}
}
/* If the createFlag parameter is true and the search did not reveal an
** exact match for the name, number of arguments and encoding, then add a
** new entry to the hash table and return it.
*/
if( createFlag && (bestScore<6 || pBest->nArg!=nArg) &&
(pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
pBest->zName = (char *)&pBest[1];
pBest->nArg = (u16)nArg;
pBest->iPrefEnc = enc;
memcpy(pBest->zName, zName, nName);
pBest->zName[nName] = 0;
sqlite3FuncDefInsert(&db->aFunc, pBest);
}
if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
return pBest;
}
return 0;
}