/* in OCaml the file name is the module name used in the language
* with it first letter put in upper case */
static void computeModuleName ( void )
{
/* in Ocaml the file name define a module.
* so we define a module =)
*/
const char *filename = getInputFileName ();
int beginIndex = 0;
int endIndex = strlen (filename) - 1;
vString *moduleName = vStringNew ();
while (filename[endIndex] != '.' && endIndex > 0)
endIndex--;
/* avoid problem with path in front of filename */
beginIndex = endIndex;
while (beginIndex > 0)
{
if (filename[beginIndex] == '\\' || filename[beginIndex] == '/')
{
beginIndex++;
break;
}
beginIndex--;
}
vStringNCopyS (moduleName, &filename[beginIndex], endIndex - beginIndex);
vStringTerminate (moduleName);
if (isLowerAlpha (moduleName->buffer[0]))
moduleName->buffer[0] += ('A' - 'a');
addTag (moduleName, K_MODULE);
vStringDelete (moduleName);
}
CXXToken * cxxTokenCreateAnonymousIdentifier(enum CXXTagKind k)
{
g_uNextAnonumousIdentiferId++;
char szNum[32];
CXXToken * t = cxxTokenCreate();
t->eType = CXXTokenTypeIdentifier;
vStringCopyS(t->pszWord, "__anon");
// The names of anonymous structures depend on the name of
// the file being processed so the identifiers won't collide across
// multiple ctags runs with different file sets.
unsigned int uHash = hash((const unsigned char *)getInputFileName());
sprintf(szNum,"%08x%02x%02x",uHash,g_uNextAnonumousIdentiferId, k);
vStringCatS(t->pszWord,szNum);
t->bFollowedBySpace = TRUE;
t->iLineNumber = getInputLineNumber();
t->oFilePosition = getInputFilePosition();
return t;
}
static void
findJsTags (void)
{
g_assert (symbols == NULL);
g_assert (tags == NULL);
JSNode * global = js_node_new_from_file (getInputFileName());
JSContext *my_cx;
GList *calls = NULL;
my_cx = js_context_new_from_node (global, &calls);
findTags (my_cx);
/*Members*/
get_member_list (my_cx);
g_list_foreach (tags, (GFunc)makeTagEntry, NULL);
findGlobal (my_cx);
g_list_free (symbols);
symbols = NULL;
g_list_free (tags);
tags = NULL;
}
extern void debugAssert (const char *assertion, const char *file, unsigned int line, const char *function)
{
fprintf(stderr, "ctags: %s:%u: %s%sAssertion `%s' failed.\n",
file, line,
function ? function : "", function ? ": " : "",
assertion);
if (getInputFileName())
{
fprintf(stderr, "ctags: %s:%u: parsing %s:%lu as %s\n",
file, line,
getInputFileName(), getInputLineNumber(),
getInputLanguageName());
}
fflush(stderr);
abort();
}
extern void findXMLTags (xmlXPathContext *ctx, xmlNode *root,
const tagXpathTableTable *xpathTableTable,
const kindOption* const kinds,void *userData)
{
boolean usedAsEnterPoint = FALSE;
xmlDocPtr doc = NULL;
if (ctx == NULL)
{
usedAsEnterPoint = TRUE;
findRegexTags ();
xmlSetGenericErrorFunc (NULL, suppressWarning);
doc = makeXMLDoc ();
if (doc == NULL)
{
verbose ("could not parse %s as a XML file\n", getInputFileName());
return;
}
ctx = xmlXPathNewContext (doc);
if (ctx == NULL)
error (FATAL, "failed to make a new xpath context for %s", getInputFileName());
root = xmlDocGetRootElement(doc);
if (root == NULL)
{
verbose ("could not get the root node for %s\n", getInputFileName());
goto out;
}
}
findXMLTagsCore (ctx, root, xpathTableTable, kinds, userData);
out:
if (usedAsEnterPoint)
{
xmlXPathFreeContext (ctx);
if (doc != getInputFileUserData ())
xmlFreeDoc (doc);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setInputFileName( reader->readString( "InputFileName", getInputFileName() ) );
setDataContainerName( reader->readString( "DataContainerName", getDataContainerName() ) );
setCellAttributeMatrixName( reader->readString( "CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setImageDataArrayName( reader->readString( "ImageDataArrayName", getImageDataArrayName() ) );
reader->closeFilterGroup();
}
bool ContextFisher::isValidState()
{
if (!ContextIntersect::isValidState()) {
return false;
}
// Tests for stranded merge
//
if (_desiredStrand != FileRecordMergeMgr::ANY_STRAND) { // requested stranded merge
for (int i=0; i < getNumInputFiles(); i++) {
// make sure file has strand.
if (!getFile(i)->recordsHaveStrand()) {
_errorMsg = "\n***** ERROR: stranded merge requested, but input file ";
_errorMsg += getInputFileName(i);
_errorMsg += " does not have strands. *****";
return false;
}
//make sure file is not VCF.
if (getFile(1)->getFileType() == FileRecordTypeChecker::VCF_FILE_TYPE) {
_errorMsg = "\n***** ERROR: stranded merge not supported for VCF file ";
_errorMsg += getInputFileName(i);
_errorMsg += ". *****";
return false;
}
}
}
if (_genomeFile == NULL){
_errorMsg = "\nERROR*****: specify -g genome file*****\n";
return false;
}
//column operations not allowed with BAM input
if (hasColumnOpsMethods() &&
getFile(0)->getFileType() == FileRecordTypeChecker::BAM_FILE_TYPE) {
_errorMsg = "\n***** ERROR: stranded merge not supported for VCF files. *****";
return false;
}
return true;
}
static void matchTagPattern (const vString* const line,
const regexPattern* const patbuf,
const regmatch_t* const pmatch)
{
vString *const name = substitute (vStringValue (line),
patbuf->u.tag.name_pattern, BACK_REFERENCE_COUNT, pmatch);
vStringStripLeading (name);
vStringStripTrailing (name);
if (vStringLength (name) > 0)
makeRegexTag (name, &patbuf->u.tag.kind);
else
error (WARNING, "%s:%ld: null expansion of name pattern \"%s\"",
getInputFileName (), getInputLineNumber (),
patbuf->u.tag.name_pattern);
vStringDelete (name);
}
static void addTag (vString* ident, const char* type, const char* arg_list, int kind, unsigned long line, MIOPos pos, vString *scope, int parent_kind)
{
if (kind == K_NONE)
return;
tagEntryInfo tag;
initTagEntry(&tag, ident->buffer, &(rustKinds[kind]));
tag.lineNumber = line;
tag.filePosition = pos;
tag.sourceFileName = getInputFileName();
tag.extensionFields.signature = arg_list;
tag.extensionFields.varType = type;
if (parent_kind != K_NONE)
{
tag.extensionFields.scopeKind = &(rustKinds[parent_kind]);
tag.extensionFields.scopeName = scope->buffer;
}
makeTagEntry(&tag);
}
extern void makeFileTag (const char *const fileName)
{
boolean via_line_directive = (strcmp (fileName, getInputFileName()) != 0);
xtagType xtag = XTAG_UNKNOWN;
if (isXtagEnabled(XTAG_FILE_NAMES))
xtag = XTAG_FILE_NAMES;
if (isXtagEnabled(XTAG_FILE_NAMES_WITH_TOTAL_LINES))
xtag = XTAG_FILE_NAMES_WITH_TOTAL_LINES;
if (xtag != XTAG_UNKNOWN)
{
tagEntryInfo tag;
kindOption *kind;
kind = getInputLanguageFileKind();
Assert (kind);
kind->enabled = isXtagEnabled(XTAG_FILE_NAMES);
/* TODO: you can return here if enabled == FALSE. */
initTagEntry (&tag, baseFilename (fileName), kind);
tag.isFileEntry = TRUE;
tag.lineNumberEntry = TRUE;
markTagExtraBit (&tag, xtag);
if (via_line_directive || (!isXtagEnabled(XTAG_FILE_NAMES_WITH_TOTAL_LINES)))
{
tag.lineNumber = 1;
}
else
{
while (readLineFromInputFile () != NULL)
; /* Do nothing */
tag.lineNumber = getInputLineNumber ();
}
makeTagEntry (&tag);
}
}
static void skipToMatch (const char *const pair)
{
const int begin = pair [0], end = pair [1];
const unsigned long inputLineNumber = getInputLineNumber ();
int matchLevel = 1;
int c = '\0';
while (matchLevel > 0)
{
c = nextChar ();
if (c == begin)
++matchLevel;
else if (c == end)
--matchLevel;
else if (c == '\n')
break;
}
if (c == EOF)
verbose ("%s: failed to find match for '%c' at line %lu\n",
getInputFileName (), begin, inputLineNumber);
}
static void
findTags (void)
{
xmlNode *i;
xmlDocPtr doc = xmlParseFile(getInputFileName());
xmlNode *root;
if (doc == NULL) {
g_warning ("could not parse file");
}
root = xmlDocGetRootElement(doc);
for (i = root->children; i; i = i->next)
{
xmlNode *j;
if (!i->name)
continue;
if (strcmp ((const char*)i->name, "namespace") !=0)
continue;
for (j = i->children; j; j = j->next)
{
makeTags (j, NULL);
}
}
}
static void findBasicTags (void)
{
const char *line;
const char *extension = fileExtension (getInputFileName ());
KeyWord *keywords;
if (strcmp (extension, "bb") == 0)
keywords = blitzbasic_keywords;
else if (strcmp (extension, "pb") == 0)
keywords = purebasic_keywords;
else
keywords = freebasic_keywords;
while ((line = (const char *) readLineFromInputFile ()) != NULL)
{
const char *p = line;
KeyWord const *kw;
while (isspace (*p))
p++;
/* Empty line? */
if (!*p)
continue;
/* In Basic, keywords always are at the start of the line. */
for (kw = keywords; kw->token; kw++)
if (match_keyword (p, kw)) break;
/* Is it a label? */
if (strcmp (extension, "bb") == 0)
match_dot_label (p);
else
match_colon_label (p);
}
}
int main(){
FILE *file = fopen("a.img", "r"); //打开 a.img
RootDir* rd = (RootDir*)malloc(sizeof(RootDir)); //分配地址空间
memset(rd, 0, sizeof(RootDir));
readFile(file, "", ROOT_START, rd);
while(TRUE){
fseek(file, 0, SEEK_SET);
memset(input,0,sizeof(input));
printf(">>");
gets(input);
//printf("\n");
//printf("%s\n",input);
if(input[0]=='!')
break;
if(isInputDir(input)){
readDirByPath(file,input,"", ROOT_START, rd);
}
else{
char name[20];
char dir[MAX];
BOOL found=FALSE;
getInputFileName(name,input);
getInputDir(dir,input);
readFileByPath(file,name,dir,"", ROOT_START, rd, &found);
if(!found)
printf("Not Found!\n");
}
}
free(rd);
fclose(file);
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::dataCheck()
{
setErrorCondition(0);
//check file name exists
if(getInputFileName().isEmpty())
{
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), "The input file name must be set before executing this filter.", getErrorCondition());
return;
}
//read image metadata
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO(getInputFileName().toLocal8Bit().constData(), itk::ImageIOFactory::ReadMode);
if(NULL == imageIO)
{
setErrorCondition(-2);
QString message = QObject::tr("Unable to read image '%1'").arg(getInputFileName());
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
imageIO->SetFileName(getInputFileName().toLocal8Bit().data());
imageIO->ReadImageInformation();
//get size of image
const size_t numDimensions = imageIO->GetNumberOfDimensions();
int xdim = imageIO->GetDimensions(0);
int ydim = imageIO->GetDimensions(1);
int zdim = 1;
if(3 != numDimensions)
{
if(2 == numDimensions)
{
//allow 2 dimensional images (as 3d image with size 1 in the z direction)
}
else
{
QString message = QObject::tr("3 dimensional image required (slected image dimensions: %1)").arg(numDimensions);
setErrorCondition(-3);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
else
{
zdim = imageIO->GetDimensions(2);
}
//determine if container/attribute matrix already exist. if so check size compatibility
DataArrayPath createdPath;
DataContainer::Pointer m;
AttributeMatrix::Pointer cellAttrMat;
createdPath.update(getDataContainerName(), getCellAttributeMatrixName(), getImageDataArrayName() );
m = getDataContainerArray()->getDataContainer(getDataContainerName());
bool createAttributeMatrix = false;
if(NULL == m.get()) //datacontainer doesn't exist->create
{
m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
m->getGeometryAs<ImageGeom>()->setDimensions(xdim, ydim, zdim);
double zRes = 1;
double zOrigin = 0;
if(3 == numDimensions)
{
zRes = imageIO->GetSpacing(2);
zOrigin = imageIO->GetOrigin(2);
}
m->getGeometryAs<ImageGeom>()->setResolution(imageIO->GetSpacing(0), imageIO->GetSpacing(0), zRes);
m->getGeometryAs<ImageGeom>()->setOrigin(imageIO->GetOrigin(0), imageIO->GetOrigin(1), zOrigin);
createAttributeMatrix = true;
if(getErrorCondition() < 0) { return; }
}
else //datacontainer exists, check if attribute matrix exists
{
bool dcExists = m->doesAttributeMatrixExist(getCellAttributeMatrixName());
ImageGeom::Pointer image = m->getPrereqGeometry<ImageGeom, AbstractFilter>(this);
if(getErrorCondition() < 0) { return; }
size_t iDims[3] = { 0, 0, 0 };
float iRes[3] = { 0.0f, 0.0f, 0.0f };
float iOrigin[4] = { 0.0f, 0.0f, 0.0f };
image->getDimensions(iDims);
image->getResolution(iRes);
image->getOrigin(iOrigin);
if(dcExists && NULL != image.get())//attribute matrix exists, check compatibility
{
//get matrix
cellAttrMat = m->getPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), false);
if(getErrorCondition() < 0) { return; }
//check dimension compatibility
QVector<size_t> tDims = cellAttrMat->getTupleDimensions();
if(tDims[0] != xdim || iDims[0] != xdim)
{
QString message = QObject::tr("The x size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(xdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[0]);
setErrorCondition(-4);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(tDims[1] != ydim || iDims[1] != ydim)
{
QString message = QObject::tr("The y size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(ydim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[1]);
setErrorCondition(-5);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(3 == numDimensions)
{
if(tDims[2] != zdim || iDims[2] != zdim)
{
QString message = QObject::tr("The z size of '%1' (%2) does not match the x size of '%3' (%4)").arg(getInputFileName()).arg(zdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName()).arg(tDims[2]);
setErrorCondition(-6);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
else
{
if(tDims[2] != 1 || iDims[2] != 1)
{
QString message = QObject::tr("The z size of '%1' (%2) does not match the x size of '%3' (1)").arg(getInputFileName()).arg(zdim).arg(getDataContainerName() + "/" + getCellAttributeMatrixName());
setErrorCondition(-7);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
}
}
else //attribute matrix doesn't exist, create
{
createAttributeMatrix = true;
}
}
//image/attribute matrix dimensions
QVector<size_t> tDims(3, 0);
tDims[0] = xdim;
tDims[1] = ydim;
tDims[2] = zdim;
//create attribute matrix if needed
if(createAttributeMatrix)
{
//create attribute matrix
cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0) { return; }
}
//check pixel type (scalar, vector, etc) for support
QVector<size_t> componentDims(1, 0);
itk::ImageIOBase::IOPixelType pixelType = imageIO->GetPixelType();
switch(pixelType)
{
case itk::ImageIOBase::SCALAR:
componentDims[0] = 1;
break;
case itk::ImageIOBase::RGB:
componentDims[0] = 3;
break;
case itk::ImageIOBase::RGBA:
componentDims[0] = 4;
break;
default:
setErrorCondition(-80001);
notifyErrorMessage(getHumanLabel(), "The Pixel Type of the image is not supported with DREAM3D.", getErrorCondition());
}
// Check to make sure everything is OK with reading the image
if(getErrorCondition() < 0)
{
std::string pixelTypeName = itk::ImageIOBase::GetPixelTypeAsString(pixelType);
QString message = QObject::tr("The pixel type of '%1' (%2) is unsupported").arg(getInputFileName()).arg(QString::fromStdString(pixelTypeName));
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
//Now get how the actual image data is stored.
IDataArray::Pointer data;
itk::ImageIOBase::IOComponentType componentType = imageIO->GetComponentType();
if(itk::ImageIOBase::CHAR == componentType)
{
data = Int8ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::UCHAR == componentType)
{
data = UInt8ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::SHORT == componentType)
{
data = Int16ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::USHORT == componentType)
{
data = UInt16ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::INT == componentType)
{
data = Int32ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::UINT == componentType)
{
data = UInt32ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::LONG == componentType)
{
data = Int64ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::ULONG == componentType)
{
data = UInt64ArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::FLOAT == componentType)
{
data = FloatArrayType::CreateArray(0, "Temp", false);
}
else if(itk::ImageIOBase::DOUBLE == componentType)
{
data = DoubleArrayType::CreateArray(0, "Temp", false);
}
else
{
std::string componentTypeName = itk::ImageIOBase::GetComponentTypeAsString(componentType);
QString message = QObject::tr("The component type type of '%1' (%2) is unsupported").arg(getInputFileName()).arg(QString::fromStdString(componentTypeName));
setErrorCondition(-9);
notifyErrorMessage(getHumanLabel(), message, getErrorCondition());
return;
}
if(getErrorCondition() < 0) { return; }
m_ImageDataPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, createdPath, componentDims, data);
if( NULL != m_ImageDataPtr.lock().get() )
{
m_ImageData = m_ImageDataPtr.lock()->getVoidPointer(0);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::execute()
{
QString ss;
dataCheck();
if(getErrorCondition() < 0)
{
setErrorCondition(-10000);
ss = QObject::tr("DataCheck did not pass during execute");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
//get volume container
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
//get input and output data
IDataArray::Pointer imageData = m_ImageDataPtr.lock();
//std::string fileNameString = getInputFileName().toLocal8Bit().constData();
//const char* fileNameCStr = fileNameString.c_str();
//execute type dependant portion using a Private Implementation that takes care of figuring out if
// we can work on the correct type and actually handling the algorithm execution. We pass in "this" so
// that the private implementation can get access to the current object to pass up status notifications,
// progress or handle "cancel" if needed.
if(ReadImagePrivate<int8_t>()(imageData))
{
ReadImagePrivate<int8_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint8_t>()(imageData) )
{
ReadImagePrivate<uint8_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int16_t>()(imageData) )
{
ReadImagePrivate<int16_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint16_t>()(imageData) )
{
ReadImagePrivate<uint16_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int32_t>()(imageData) )
{
ReadImagePrivate<int32_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint32_t>()(imageData) )
{
ReadImagePrivate<uint32_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<int64_t>()(imageData) )
{
ReadImagePrivate<int64_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<uint64_t>()(imageData) )
{
ReadImagePrivate<uint64_t>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<float>()(imageData) )
{
ReadImagePrivate<float>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else if(ReadImagePrivate<double>()(imageData) )
{
ReadImagePrivate<double>::Execute(this, getInputFileName(), imageData, m, getCellAttributeMatrixName());
}
else
{
setErrorCondition(-10001);
ss = QObject::tr("A Supported DataArray type was not used for an input array.");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
attrMat->addAttributeArray(getImageDataArrayName(), imageData);
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
bool SlangRS::checkODR(const char *CurInputFile) {
for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(),
E = mRSContext->exportable_end();
I != E;
I++) {
RSExportable *RSE = *I;
if (RSE->getKind() != RSExportable::EX_TYPE)
continue;
RSExportType *ET = static_cast<RSExportType *>(RSE);
if (ET->getClass() != RSExportType::ExportClassRecord)
continue;
RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET);
// Artificial record types (create by us not by user in the source) always
// conforms the ODR.
if (ERT->isArtificial())
continue;
// Key to lookup ERT in ReflectedDefinitions
llvm::StringRef RDKey(ERT->getName());
ReflectedDefinitionListTy::const_iterator RD =
ReflectedDefinitions.find(RDKey);
if (RD != ReflectedDefinitions.end()) {
const RSExportRecordType *Reflected = RD->getValue().first;
// There's a record (struct) with the same name reflected before. Enforce
// ODR checking - the Reflected must hold *exactly* the same "definition"
// as the one defined previously. We say two record types A and B have the
// same definition iff:
//
// struct A { struct B {
// Type(a1) a1, Type(b1) b1,
// Type(a2) a2, Type(b1) b2,
// ... ...
// Type(aN) aN Type(b3) b3,
// }; }
// Cond. #1. They have same number of fields, i.e., N = M;
// Cond. #2. for (i := 1 to N)
// Type(ai) = Type(bi) must hold;
// Cond. #3. for (i := 1 to N)
// Name(ai) = Name(bi) must hold;
//
// where,
// Type(F) = the type of field F and
// Name(F) = the field name.
bool PassODR = false;
// Cond. #1 and Cond. #2
if (Reflected->equals(ERT)) {
// Cond #3.
RSExportRecordType::const_field_iterator AI = Reflected->fields_begin(),
BI = ERT->fields_begin();
for (unsigned i = 0, e = Reflected->getFields().size(); i != e; i++) {
if ((*AI)->getName() != (*BI)->getName())
break;
AI++;
BI++;
}
PassODR = (AI == (Reflected->fields_end()));
}
if (!PassODR) {
getDiagnostics().Report(mDiagErrorODR) << Reflected->getName()
<< getInputFileName()
<< RD->getValue().second;
return false;
}
} else {
llvm::StringMapEntry<ReflectedDefinitionTy> *ME =
llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey.begin(),
RDKey.end());
ME->setValue(std::make_pair(ERT, CurInputFile));
if (!ReflectedDefinitions.insert(ME))
delete ME;
// Take the ownership of ERT such that it won't be freed in ~RSContext().
ERT->keep();
}
}
return true;
}
void dxf2shpConverterGui::on_btnBrowseForFile_clicked()
{
getInputFileName();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReadImage::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FileSystemFilterParameter::New("Input File", "InputFileName", FilterParameterWidgetType::InputFileWidget, getInputFileName(), false, "", "*.tif *.jpeg *.png *.bmp", "Image"));
parameters.push_back(FilterParameter::New("Created Information", "", FilterParameterWidgetType::SeparatorWidget, "", true));
parameters.push_back(FilterParameter::New("Data Container Name", "DataContainerName", FilterParameterWidgetType::StringWidget, getDataContainerName(), true, ""));
parameters.push_back(FilterParameter::New("Cell Attribute Matrix Name", "CellAttributeMatrixName", FilterParameterWidgetType::StringWidget, getCellAttributeMatrixName(), true, ""));
parameters.push_back(FilterParameter::New("ImageData", "ImageDataArrayName", FilterParameterWidgetType::StringWidget, getImageDataArrayName(), true, ""));
setFilterParameters(parameters);
}
