void CXBindingsCppObjectsGenerator::DoGenerateMacroForChildEnumerator( CXBindingsRuleInfo& ruleInfo , CXBindingsArrayGrammarChildInfo& childs , CXBindings& , CXBindingsGeneratorOptions& ) { /** @todo manage here enumaration for types different from a string */ if( childs.size() > 0 ) { std::string child_enum_list; std::string child_string_enum_list; for( unsigned int i = 0; i < childs.size() ; ++i ) { if( i == 0 ) child_enum_list += "\t$(ns)" + childs[i].properties[ruleInfo.variable.content] + " = 0,\n" ; else child_enum_list += "\t$(ns)" + childs[i].properties[ruleInfo.variable.content] + ",\n" ; std::string str = GetMacro("string_composer") ; SetMacro("content",childs[i].properties[ruleInfo.variable.content]) ; DoReplaceMacros( str ); if( i < childs.size()-1 ) child_string_enum_list += "\t" + str + ",\n" ; else child_string_enum_list += "\t" + str; } SetMacro( "child_enum_list" , child_enum_list ) ; SetMacro( "child_string_enum_list" , child_string_enum_list ) ; } }
//--------------------------------------------------------------------------- void __fastcall TDBAwareForm::ComboBox2Change(TObject *Sender) { AnsiString order; switch (ComboBox2->ItemIndex) { case 0: { order = "ORDERS.\"SaleDate\""; break; } case 1: { order = "ORDERS.\"ShipDate\""; break; } case 2: { order = "ORDERS.\"CustNo\""; break; } case 3: { order = "ORDERS.\"EmpNo\""; break; } default: return; } SetMacro("ORDER", order); }
bool CXBindingsGenerator::GenerateCode( CXBindingsGeneratorOptions& options ) { SetDefaultMacros(options); m_grammar = (CXBindings*) CXBindingsXmlReader::Get()->LoadFile(options.grammarFile); if( m_grammar == NULL ) CXB_THROW( "Error reading your grammar file : " + options.grammarFile ); m_interpreterInfo = m_interpreter.DoExtractObjectsInformation(options.baseFile,*m_grammar,options); m_genfile = (CXBindingsGeneratorFile*) CXBindingsXmlReader::Get()->LoadFile(options.interpreterFile); if( m_genfile == NULL ) CXB_THROW("Error reading your file :" + options.interpreterFile ); // push all var nodes extracted from the genfile as macros for the Generator CXBindingsArrayGrammarGeneratorFileVar& vars = m_genfile->GetVariables( ); for( unsigned int i = 0; i < vars.size() ; ++i ) SetMacro( vars[i].GetName() , vars[i].GetContent() ); CXBindingsStringStringMap& types = m_genfile->GetTypeInfo().GetTypes(); m_baseTypes = types; return DoGenerateCode( options ); }
//--------------------------------------------------------------------------- void __fastcall TDBAwareForm::DBGrid1TitleBtnClick(TObject *Sender, long ACol, TField *Field) { if (Field != NULL) { SetMacro("ORDER", Field->FieldName); ComboBox2->ItemIndex = -1; } }
//--------------------------------------------------------------------------- void __fastcall TDBAwareForm::rxDBLookupCombo2Change(TObject *Sender) { AnsiString s; s = "0=0"; if (rxDBLookupCombo2->Value != "") { s = "ORDERS.\"CustNo\"=" + rxDBLookupCombo2->Value; } SetMacro("CUSTOMER", s); }
VOID Mij_SetProfile( MOTIONINJOY_APP_OPTION* Configuration ) { HANDLE driverHandle; IO_STATUS_BLOCK isb; BOOLEAN setTestMacro = FALSE; if (setTestMacro) { MOTIONINJOY_MACRO macro; Memory_Clear(¯o, sizeof(MOTIONINJOY_MACRO)); macro.Duration = 800; //800 milli-seconds Memory_Copy(macro.Command, SomeMacro, sizeof(macro.Command)); macro.ButtonIntervals[0][10] = 0x01; //0ms macro.ButtonIntervals[1][10] = 0x02; //100ms macro.ButtonIntervals[2][10] = 0x04; //200ms macro.ButtonIntervals[3][10] = 0x08; //300ms macro.ButtonIntervals[4][10] = 0x10; //400ms macro.ButtonIntervals[5][10] = 0x20; //500ms SetMacro(1, ¯o); } File_Create( &driverHandle, L"\\\\.\\MIJFilter", SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL ); if (setTestMacro) Configuration->InputOption.Maping.Triangle = Macro1; //set triangle button to macro NtDeviceIoControlFile(driverHandle, NULL, NULL, NULL, &isb, IOCTL_MIJ_SET_CONFIG_OPTIONS, Configuration, 256, NULL, 0); File_Close(driverHandle); }
void dlgManageMacros::OnSave(wxCommandEvent &ev) { if (!thisMacroChanged) return; SetMacro(false); }
void dlgManageMacros::OnOK(wxCommandEvent &ev) { if (thisMacroChanged) SetMacro(true); EndModal(wxID_OK); }
CXBindingsFileInfo CXBindingsCppObjectsGenerator::DoGenerateRuleCodeFor( CXBindingsRuleInfo& ruleInfo , CXBindings& , CXBindingsGeneratorOptions& options ) { CXBindingsFileInfo res; //wxLogMessage( "\t\t Rule make is : ") + ruleInfo.make ; //wxLogMessage( "\t\t Rule name is : ") + ruleInfo.name.content ; //wxLogMessage( "\t\t Rule type is : ") + ruleInfo.type.content ; CXBindingsStringStringMap& types = m_genfile->GetTypeInfo().GetTypes(); std::string realType = ruleInfo.type.content; std::string typeTemplate = ruleInfo.type.stemplate; CXBindingsGeneratorFileTemplate* arrayTemplate = NULL; CXBindingsStringStringMap::iterator it = types.find( realType ); realType = GetRealType( realType , options ); std::string typeExt = realType; if( !IsKnownType( realType ) ) typeExt = GetRealType( realType , options ); if( it != types.end() ) { realType = it->second; typeExt = realType; } std::string savedType = typeExt; if( typeTemplate == "array") { typeExt = "std::vector< " + typeExt + " >" ; arrayTemplate = m_genfile->FindTemplate( "array_addons") ; } if( ruleInfo.make == "import") { // We have to add here all informations about the object from which this one is derived // this information is contained in the realType variable /* for each element in the info object of the grammar */ CXBindings& grammar = m_interpreterInfo.grammar; CXBindingsInfo& info = grammar.GetInfo(); CXBindingsArrayString genOrder = info.GetGeneration().GetObjects(); /* The first thing to do is to estabilsh the generation objects dependecy list * So that object will be generated in the right order... */ CXBindingsArrayString dependencies; for( unsigned int i = 0; i < genOrder.size() ; ++i ) { CXBindingsArrayGrammarObjectInfoMap& objectsInfoMap = m_interpreterInfo.objects; CXBindingsArrayGrammarObjectInfo& objectsInfo = objectsInfoMap[genOrder[i]]; for( unsigned int j = 0; j < objectsInfo.size() ; ++j ) { std::string name = objectsInfo[j].properties["name" ]; name = GetRealType( name , options ); if( name == savedType ) { std::pair< std::string , CXBindingsFileInfo> inf( name , m_objectInfos[name] ); res.bases.push_back( inf ); return res; } } } std::pair< std::string , CXBindingsFileInfo> inf( savedType , m_objectInfos[savedType] ); res.bases.push_back( inf ); return res; } std::string nameExt = ruleInfo.name.content; nameExt = GetPropertyExtension( nameExt , options ); SetMacro( "name_extension" , nameExt) ; SetMacro( "name" , ruleInfo.name.content) ; SetMacro( "type" , typeExt) ; SetMacro( "real_type" , savedType) ; SetMacro( "variable" , ruleInfo.variable.content) ; CXBindingsGeneratorFileTemplate* rTemplate = m_genfile->FindTemplate( ruleInfo.make ); if( rTemplate == NULL ) CXB_THROW( "Error cannot find template : " + ruleInfo.make) ; if( ruleInfo.make == "property" || ruleInfo.make == "attribute" ) { std::pair< std::string , std::string > mpair( ruleInfo.name.content , typeExt ); res.properties.push_back( mpair ); } if( ruleInfo.make == "property" || ruleInfo.make == "attribute" || ruleInfo.make == "variant_accessor" || ruleInfo.make == "variant_array_accessor") { std::pair< std::string , std::string > mpair( ruleInfo.name.content , savedType ); res.dependencies.push_back( mpair ); } CXBindingsArrayGrammarGeneratorFileObjectPart& objects = rTemplate->GetObjects(); for( unsigned int i = 0; i < objects.size() ; ++i ) { std::string content = objects[i].GetContent(); DoReplaceMacros( content ); if( objects[i].GetFile() =="header") { if( objects[i].GetPermission() == "private") res.headerPrivateInfo += content; else if( objects[i].GetPermission() == "protected") res.headerProtectedInfo += content; else res.headerPublicInfo += content; } else res.srcInfo += content; } if( arrayTemplate != NULL ) { CXBindingsArrayGrammarGeneratorFileObjectPart& objectsArray = arrayTemplate->GetObjects(); for( unsigned int i = 0; i < objectsArray.size() ; ++i ) { std::string content = objectsArray[i].GetContent(); DoReplaceMacros( content ); if( objectsArray[i].GetFile() =="header") { if( objectsArray[i].GetPermission() == "private") res.headerPrivateInfo += content; else if( objectsArray[i].GetPermission() == "protected") res.headerProtectedInfo += content; else res.headerPublicInfo += content; } else res.srcInfo += content; } } return res; }
bool CXBindingsCppObjectsGenerator::DoGenerateCode( CXBindingsGeneratorOptions& options ) { /* for each element in the info object of the grammar */ CXBindings& grammar = m_interpreterInfo.grammar; CXBindingsInfo& info = grammar.GetInfo(); CXBindingsArrayString genOrder = info.GetGeneration().GetObjects(); CXBindingsArrayString templates = info.GetGeneration().GetTemplates(); /* The first thing to do is to estabilsh the generation objects dependecy list * So that object will be generated in the right order... */ CXBindingsArrayString dependencies = DoCreateDependencyList( options ); /** @todo here generate object in their dependencies order is this really usefull .??? */ for( unsigned int k = 0; k < dependencies.size() ; ++k ) { for( unsigned int i = 0; i < genOrder.size() ; ++i ) { CXBindingsArrayGrammarObjectInfoMap& objectsInfoMap = m_interpreterInfo.objects; CXBindingsArrayGrammarObjectInfo& objectsInfo = objectsInfoMap[genOrder[i]]; for( unsigned int j = 0; j < objectsInfo.size() ; ++j ) { std::string realName = objectsInfo[j].properties["name"]; realName = GetRealType( realName , options ); if( realName == dependencies[k] ) { DoGenerateCodeFor( objectsInfo[j] , grammar , options ); break; } } } } /** The last step is to generate the globals file and the other files for given objects */ std::string hdrDir = options.genDir + "/include" ; std::string srcDir = options.genDir + "/src" ; CXBindingsMakeDirRecursively(hdrDir+"/") ; CXBindingsMakeDirRecursively(srcDir+"/") ; /* First generate globals file definitions */ std::string global_file = GetMacro( "global_file") ; std::string global_file_src = GetMacro( "global_file_src") ; std::string filename = options.ns + "_globals" ; SetMacro( "filename" , filename) ; SetMacro( "globals_code" , m_globalInfo.headerPublicInfo) ; SetMacro( "globals_code_src" , m_globalInfo.srcInfo) ; DoReplaceMacros( global_file ); DoReplaceMacros( global_file_src ); SaveFile( hdrDir + "/" + filename + ".h" , global_file ); SaveFile( srcDir + "/" + filename + ".cpp" , global_file_src) ; // Generate additional files CXBindingsArrayGrammarGeneratorFileAddin& addins = m_genfile->GetAddins(); for( unsigned int i = 0; i < addins.size() ; ++i ) { std::string fname = addins[i].GetName(); std::string header = addins[i].GetHeader(); std::string source = addins[i].GetSource(); if( !header.empty() ) { DoReplaceMacros( header ); SaveFile( hdrDir + "/" + fname + ".h" , header) ; } if( !source.empty() ) { DoReplaceMacros( source ); SaveFile( srcDir + "/" + fname + ".cpp" , source) ; } } // Save generated objects code CXBindingsFileInfoMap::iterator it = m_objectInfos.begin(); for( ; it != m_objectInfos.end() ; ++it ) { if( m_objectFiles[it->first] !=filename && !m_objectFiles[it->first].empty() ) { std::string srcFile = srcDir + "/" + m_objectFiles[it->first] + ".cpp" ; std::string hdrFile = hdrDir + "/" + m_objectFiles[it->first] + ".h" ; if( !it->second.srcInfo.empty() ) { SaveFile( srcFile , it->second.srcInfo ); } SaveFile( hdrFile , it->second.headerPublicInfo ); } } return false; }
void CXBindingsCppObjectsGenerator::DoCreateParametersMacrosFor( CXBindingsFileInfo& file , CXBindingsFileParametersMacros& parameters , CXBindingsGeneratorOptions& options ) { for( unsigned int i = 0; i < file.properties.size() ; ++i ) { std::string pName = file.properties[i].first; std::string pType = file.properties[i].second; //wxLogMessage( pName + " - ") + pType ; std::string nameExt = GetPropertyExtension( pName , options ); SetMacro( "content_type" , pType) ; SetMacro( "content" , pName) ; SetMacro( "content_ext" , nameExt) ; std::string str,str2; str = GetMacro("ctor_var_composer") ; str2 = GetMacro( "ctor_var_composer2") ; DoReplaceMacros(str); DoReplaceMacros(str2); if( parameters.parameters_copy_list.empty() && !str.empty() ) { parameters.parameters_ctor_list += str; parameters.parameters_ctor_list2 += str2; } else if( !str.empty() ) { parameters.parameters_ctor_list += " ," + str; parameters.parameters_ctor_list2 += " ," + str2; } str = GetMacro("var_eqop_composer") ; DoReplaceMacros(str); parameters.parameters_eqop_list += str; str = GetMacro("var_definit_composer") ; DoReplaceMacros(str); parameters.parameters_default_init_list += str; str = GetMacro("var_init_composer") ; DoReplaceMacros(str); parameters.parameters_init_list += str; str = GetMacro("var_copy_composer") ; DoReplaceMacros(str); parameters.parameters_copy_list += str; str = GetMacro("var_doc_composer") ; DoReplaceMacros(str); parameters.parameters_doc_list += str; str = GetMacro("var_property_composer") ; DoReplaceMacros(str); parameters.parameters_property_table += str; if( i < file.properties.size()-1 ) parameters.parameters_property_table += "\n" ; str = GetMacro("var_eqeqop_composer") ; DoReplaceMacros(str); if( i == 0 && parameters.parameters_eqeqop_list.empty() ) { parameters.parameters_eqeqop_list += "\t" + str; } else { parameters.parameters_eqeqop_list += " &&\n\t" + str; } } }
void CXBindingsCppObjectsGenerator::DoGenerateCodeFor( CXBindingsObjectInfo& objectInfo , CXBindings& grammar , CXBindingsGeneratorOptions& options ) { // STEP 0 : APPEND OBJECT PROPERTIES IN THE MACRO MAP CXBindingsStringStringMap& properties = objectInfo.properties; //wxLogMessage( "\t STEP O : Calculating Object preliminar informations : ") + properties["name" ] ; //wxLogMessage( "\t\t STEP O.1 : Appending Object macro : ") + properties["name" ] ; if( properties["name"].empty() ) CXB_THROW( "Error object with no name cannot continue...") ; std::string objectName = properties["name" ]; objectName = GetRealType( objectName , options ); std::string upName; upName += objectName; to_upper( upName ); SetMacro( "object" , objectName); SetMacro( "OBJECT" , upName) ; // @todo here the file is not preoprely set /* First set up some macros for the given file */ // filename macros std::string filename = m_objectFiles[objectName]; SetMacro( "filename" , filename) ; // STEP 1 : CHECK CHILD CONTAINERS AND RULES //wxLogMessage( "\t STEP 1 : Checking for existing rules in the child containers ... ") ; CXBindingsArrayGrammarChildContainerInfo& ccInfo = objectInfo.childs; //std::string msg = std::string::Format( "\t\t Found %d childcontainers...") , ccInfo.size() ; //wxLogMessage( msg ); CXBindingsFileInfo objectFileInfo; for( unsigned int i = 0; i < ccInfo.size() ; ++i ) { objectFileInfo += DoGenerateChildContainerCodeFor( ccInfo[i] , grammar , options ); } //wxLogMessage( "\t END STEP 1") ; // STEP 2 : CHECK CATEGORIES AND RULES //wxLogMessage( "\t STEP 2 : Checking for existing rules in the child categories ... ") ; CXBindingsArrayGrammarCategoryInfo& catInfo = objectInfo.categories; //msg = std::string::Format( "\t\t Found %d categories...") , catInfo.size() ; //wxLogMessage( msg ); for( unsigned int i = 0; i < catInfo.size() ; ++i ) { objectFileInfo += DoGenerateCategoryCodeFor( catInfo[i] , grammar , options ); } //wxLogMessage( "\t END STEP 2") ; CXBindingsArrayGrammarChildInfo& childs = objectInfo.childInfos; for( unsigned int j = 0; j < childs.size() ; ++j ) { CXBindingsFileInfo ruleContent = DoGenerateChildRuleCodeFor( childs[j] , grammar , options ); objectFileInfo += ruleContent; } //wxLogMessage( "\t STEP 3 : create additional object macros for the given object if exists ... ") ; // Append codes in the childs_header_public_code std::string childs_header_public_code = objectFileInfo.headerPublicInfo; SetMacro( "childs_header_public_code" , childs_header_public_code); std::string childs_header_private_code; childs_header_private_code = objectFileInfo.headerPrivateInfo; SetMacro( "childs_header_private_code" , childs_header_private_code) ; std::string childs_header_protected_code; childs_header_protected_code = objectFileInfo.headerProtectedInfo, SetMacro( "childs_header_protected_code" , childs_header_protected_code) ; std::string childs_src_code = objectFileInfo.srcInfo; SetMacro( "childs_src_code" , childs_src_code) ; // Finally build the missing macrods for doc comments and other parameters info CXBindingsFileParametersMacros params; /* once all parameters list have been generated, we need to create the macros of derived * objects. This is very important in order to treat the inherit template from the various * rules/ */ std::string object_bases; std::string object_bases_default_ctor; std::string object_bases_init_list; std::string object_bases_copy_list; std::string object_bases_list; for( unsigned int i = 0; i < objectFileInfo.bases.size() ; ++i ) { std::string pName = objectFileInfo.bases[i].first; CXBindingsFileInfo& inf = objectFileInfo.bases[i].second; pName = GetRealType( pName , options ); CXBindingsFileParametersMacros localp; localp.parameters_eqeqop_list = params.parameters_eqeqop_list; DoCreateParametersMacrosFor( inf , localp , options ); params.parameters_doc_list += localp.parameters_doc_list; params.parameters_ctor_list += localp.parameters_ctor_list; params.parameters_eqop_list += localp.parameters_eqop_list; params.parameters_eqeqop_list = localp.parameters_eqeqop_list; //wxLogMessage( localp.parameters_doc_list ); if( i != 0 ) { object_bases += " , public " + pName; object_bases_list += " , " + pName; object_bases_default_ctor += ",\n\t\t" + pName + "()" ; object_bases_copy_list += ",\n\t\t" + pName + "(rhs)" ; object_bases_init_list += ",\n\t\t" + pName + "(" + localp.parameters_ctor_list2 + ")" ; } else { object_bases += " public " + pName; object_bases_list += pName; object_bases_default_ctor += "\t\t" + pName + "()" ; object_bases_copy_list += "\t\t" + pName + "(rhs)" ; object_bases_init_list += " \t\t" + pName + "(" + localp.parameters_ctor_list2 + ")" ; } } if( object_bases.empty() ) { object_bases = "public $(base_object)" ; object_bases_default_ctor = "\t\t$(base_object)()" ; object_bases_copy_list = "\t\t$(base_object)()" ; object_bases_list = "$(base_object)" ; object_bases_init_list = "\t\t$(base_object)()" ; } SetMacro( "object_bases" , object_bases ) ; SetMacro( "object_bases_list" , object_bases_list) ; SetMacro( "object_bases_default_ctor" , object_bases_default_ctor) ; SetMacro( "object_bases_init_list" , object_bases_init_list) ; SetMacro( "object_bases_copy_list" , object_bases_copy_list) ; DoCreateParametersMacrosFor( objectFileInfo , params , options ); if( params.parameters_eqeqop_list.empty() ) params.parameters_eqeqop_list = "\t\ttrue"; SetMacro( "parameters_doc_list" , params.parameters_doc_list ) ; SetMacro( "parameters_ctor_list" , params.parameters_ctor_list ) ; SetMacro( "parameters_dtor_list" , params.parameters_dtor_list ) ; SetMacro( "parameters_init_list" , params.parameters_init_list ) ; SetMacro( "parameters_default_init_list" , params.parameters_default_init_list ) ; SetMacro( "parameters_copy_list" , params.parameters_copy_list ) ; SetMacro( "parameters_eqop_list" , params.parameters_eqop_list ) ; SetMacro( "parameters_eqeqop_list" , params.parameters_eqeqop_list ) ; SetMacro( "parameters_property_table" , params.parameters_property_table ) ; if( params.parameters_doc_list.empty() ) { SetMacro( "object_ctors" , "$(object_simple_ctor_header)" ) ; } else { SetMacro( "object_ctors" , "$(object_complex_ctor_header)" ) ; } /* The next step is very important ! * First we have to establish all direct dependencies in the given property list * and all dependencies of the given bases. * Once this is done, we can get the dependency list and include list to put in the * source file*/ std::string local_includes = "#include \"" + options.ns + "_globals" + ".h\"\n" ; std::string object_imports; CXBindingsArrayString lc; CXBindingsArrayString oi; CXBindingsArrayString currObj; currObj.push_back(objectName); DoGetIncludesListFor(lc,oi,currObj,objectFileInfo,options); for( unsigned int i = 0; i < lc.size() ; ++i ) { local_includes += lc[i]; object_imports += oi[i]; } if( filename != options.ns + "_globals") { object_imports += "class " + objectName + ";\n" ; } SetMacro( "local_includes" , local_includes) ; SetMacro( "object_imports" , object_imports) ; //wxLogMessage( "\t\t\t local_includes is :") + local_includes ; //wxLogMessage( "\t\t\t object_imports is :") + object_imports ; //wxLogMessage( "\t END STEP 3...") ; // STEP 4 : CHECK EXISTING RULES IN THE GIVEN OBJECT //wxLogMessage( "\t STEP 4 : Checking for existing rules in the object ... ") ; CXBindingsArrayGrammarRuleInfo& rules = objectInfo.rules; //msg = std::string::Format( "\t\t Found %d rules...") , rules.size() ; //wxLogMessage( msg ); CXBindingsFileInfo FinalInfo; for( unsigned int i = 0; i < rules.size() ; ++i ) { CXBindingsFileInfo ruleContent = DoGenerateRuleCodeFor( rules[i] , grammar , options ); FinalInfo += ruleContent; } if( filename ==options.ns + "_globals") m_globalInfo += objectFileInfo; objectFileInfo.headerPublicInfo = stdEmptyString; objectFileInfo.headerProtectedInfo = stdEmptyString; objectFileInfo.headerPrivateInfo = stdEmptyString; objectFileInfo.srcInfo = stdEmptyString; FinalInfo += objectFileInfo; //std::cout << objectName << std::endl; m_objectInfos[objectName] = FinalInfo; //wxLogMessage( "\t END STEP 4...") ; }
void CXBindingsCppHandlersGenerator::DoCreateParametersMacrosFor( CXBindingsHandlerFileInfo& file , CXBindingsHandlerFileParametersMacros& parameters , CXBindingsGeneratorOptions& options) { for( unsigned int i = 0; i < file.properties.size() ; ++i ) { std::string pName = file.properties[i].first; std::string pType = file.properties[i].second; //wxLogMessage( pName + " - ") + pType ; std::string nameExt = pName; nameExt = GetPropertyExtension( nameExt , options ); SetMacro( "name_extension", nameExt) ; SetMacro( "name" , pName) ; SetMacro( "type" , pType) ; std::string ot = pType; /* Here we have to get the types of each properties and if it's not an object * get the "real" type of the given properties (i.e : a typedef or an enumeration) */ /* first check if the type is known or not */ CXBindingsStringStringMap::iterator it = m_types.find( pName ); if( it != m_types.end() ) pType = it->second; //wxLogMessage( pName + " - ") + pType ; CXBindingsGeneratorFileTemplate* preader = NULL; CXBindingsGeneratorFileTemplate* pwriter = NULL; std::string trName = "property_reader_" + pType; std::string twName = "property_writer_" + pType; preader = m_genfile->FindTemplate( trName ); pwriter = m_genfile->FindTemplate( twName ); if( preader == NULL || pwriter == NULL ) CXB_THROW( "Error cannot find property reader and writer template for object of type : " + pType + " for variable " + pName + " original type is " + ot); CXBindingsArrayGrammarGeneratorFileObjectPart& objects = preader->GetObjects(); for( unsigned int j = 0; j < objects.size() ; ++j ) { std::string content = objects[j].GetContent(); DoReplaceMacros( content ); if( objects[j].GetFile() =="src") { parameters.property_readers += content; } } CXBindingsArrayGrammarGeneratorFileObjectPart& objectsw = pwriter->GetObjects(); for( unsigned int j = 0; j < objectsw.size() ; ++j ) { std::string content = objectsw[j].GetContent(); DoReplaceMacros( content ); if( objectsw[j].GetFile() =="src") { parameters.property_writers += content; } } } for( unsigned int i = 0; i < file.attributes.size() ; ++i ) { std::string pName = file.attributes[i].first; std::string pType = file.attributes[i].second; //wxLogMessage( pName + " - ") + pType ; std::string nameExt = pName; nameExt = GetPropertyExtension( nameExt , options ); SetMacro( "name_extension" , nameExt) ; SetMacro( "name" , pName) ; SetMacro( "type" , pType) ; /* Here we have to get the types of each attributes and if it's not an object * get the "real" type of the given attributes (i.e : a typedef or an enumeration) */ /* first check if the type is known or not */ CXBindingsStringStringMap::iterator it = m_types.find( pName ); if( it != m_types.end() ) pType = it->second; //wxLogMessage( pName + " - ") + pType ; CXBindingsGeneratorFileTemplate* preader = NULL; CXBindingsGeneratorFileTemplate* pwriter = NULL; std::string trName = "attribute_reader_" + pType; std::string twName = "attribute_writer_" + pType; preader = m_genfile->FindTemplate( trName ); pwriter = m_genfile->FindTemplate( twName ); if( preader == NULL || pwriter == NULL ) CXB_THROW( "Error cannot find attribute reader and writer template for object of type : " + pType) ; CXBindingsArrayGrammarGeneratorFileObjectPart& objects = preader->GetObjects(); for( unsigned int j = 0; j < objects.size() ; ++j ) { std::string content = objects[j].GetContent(); DoReplaceMacros( content ); if( objects[j].GetFile() =="src") { parameters.attribute_readers += content; } } CXBindingsArrayGrammarGeneratorFileObjectPart& objectsw = pwriter->GetObjects(); for( unsigned int j = 0; j < objectsw.size() ; ++j ) { std::string content = objectsw[j].GetContent(); DoReplaceMacros( content ); if( objectsw[j].GetFile() =="src") { parameters.attribute_writers += content; } } } }
void CXBindingsCppHandlersGenerator::DoGenerateCodeFor( CXBindingsObjectInfo& objectInfo , CXBindings& grammar , CXBindingsGeneratorOptions& options ) { // STEP 0 : APPEND OBJECT PROPERTIES IN THE MACRO MAP CXBindingsStringStringMap& properties = objectInfo.properties; if( properties["name"].empty() ) CXB_THROW( "Error object with no name cannot continue...") ; std::string objectName = properties["name" ]; objectName = GetRealType( objectName , options ); std::string upName; upName += objectName; to_upper( upName ); SetMacro( "object" , objectName ); SetMacro( "OBJECT" , upName ); // @todo here the file is not preoprely set /* First set up some macros for the given file */ // filename macros std::string filename = objectName + "XmlHandler" ; SetMacro( "filename" , filename) ; // STEP 1 : CHECK CHILD CONTAINERS AND RULES CXBindingsArrayGrammarChildContainerInfo& ccInfo = objectInfo.childs; CXBindingsHandlerFileInfo objectFileInfo; for( unsigned int i = 0; i < ccInfo.size() ; ++i ) { objectFileInfo += DoGenerateChildContainerCodeFor( ccInfo[i] , grammar , options ); } // STEP 2 : CHECK CATEGORIES AND RULES CXBindingsArrayGrammarCategoryInfo& catInfo = objectInfo.categories; for( unsigned int i = 0; i < catInfo.size() ; ++i ) { objectFileInfo += DoGenerateCategoryCodeFor( catInfo[i] , grammar , options ); } CXBindingsArrayGrammarChildInfo& childs = objectInfo.childInfos; for( unsigned int j = 0; j < childs.size() ; ++j ) { CXBindingsHandlerFileInfo ruleContent = DoGenerateChildRuleCodeFor( childs[j] , grammar , options ); objectFileInfo += ruleContent; } // Finally build the missing macrods for doc comments and other parameters info CXBindingsHandlerFileParametersMacros params; /* once all parameters list have been generated, we need to create the macros of derived * objects. This is very important in order to treat the inherit template from the various * rules/ */ for( unsigned int i = 0; i < objectFileInfo.bases.size() ; ++i ) { std::string pName = objectFileInfo.bases[i].first; CXBindingsHandlerFileInfo& inf = objectFileInfo.bases[i].second; CXBindingsHandlerFileParametersMacros localp; DoCreateParametersMacrosFor( inf , localp , options ); params += localp; } DoCreateParametersMacrosFor( objectFileInfo , params , options ); SetMacro( "objects_attribute_readers" , params.attribute_readers) ; SetMacro( "objects_attribute_writers" , params.attribute_writers) ; SetMacro( "objects_property_readers" , params.property_readers) ; SetMacro( "objects_property_writers" , params.property_writers) ; /* The next step is very important ! * First we have to establish all direct dependencies in the given property list * and all dependencies of the given bases. * Once this is done, we can get the dependency list and include list to put in the * source file*/ std::string local_includes; std::string object_imports; CXBindingsArrayString lc; CXBindingsArrayString currObj; currObj.push_back(objectName); DoGetIncludesListFor(lc,currObj,objectFileInfo,options); for( unsigned int i = 0; i < lc.size() ; ++i ) { local_includes += lc[i]; } SetMacro( "local_includes" , local_includes) ; //wxLogMessage( "\t\t\t local_includes is :") + local_includes ; //wxLogMessage( "\t END STEP 3...") ; // STEP 4 : CHECK EXISTING RULES IN THE GIVEN OBJECT //wxLogMessage( "\t STEP 4 : Checking for existing rules in the object ... ") ; CXBindingsArrayGrammarRuleInfo& rules = objectInfo.rules; //msg = std::string::Format( "\t\t Found %d rules...") , rules.size() ; //wxLogMessage( msg ); CXBindingsHandlerFileInfo FinalInfo; if( filename ==options.ns + "_globals") { //wxLogMessage( "Object is a typedef or an enumeration, no handler needs to be generated for.") ; return; } CXBindingsGeneratorFileTemplate* rTemplate = m_genfile->FindTemplate( "object") ; if( rTemplate == NULL ) CXB_THROW( "Error cannot find template object") ; std::string objectNodeName = properties["name" ]; boost::replace_all(objectNodeName,"Type",""); SetMacro( "object_node_name" , objectNodeName) ; CXBindingsArrayGrammarGeneratorFileObjectPart& objects = rTemplate->GetObjects(); for( unsigned int i = 0; i < objects.size() ; ++i ) { std::string content = objects[i].GetContent(); DoReplaceMacros( content ); if( objects[i].GetFile() =="header") { FinalInfo.headerInfo += content; } else FinalInfo.srcInfo += content; //wxLogMessage( "\t\t\t Generated rule content is : ") + content ; } FinalInfo += objectFileInfo; m_objectInfos[objectName] = FinalInfo; //wxLogMessage( "\t END STEP 4...") ; }
int OGRFMELayerDB::CreateReader() { FME_MsgNum err; IFMESession *poSession = poDS->GetFMESession(); FME_UInt32 i; CPLAssert( poReader == NULL && nPreviousFeature == -1 ); /* -------------------------------------------------------------------- */ /* Make a copy of the user directives, so we won't be altering */ /* the originals. */ /* -------------------------------------------------------------------- */ IFMEStringArray *poUDC = poSession->createStringArray(); for( i = 0; i < poUserDirectives->entries(); i++ ) poUDC->append( (*poUserDirectives)(i) ); /* -------------------------------------------------------------------- */ /* Update the IDLIST to just select the desired table. */ /* -------------------------------------------------------------------- */ for( i = 0; i < poUDC->entries(); i++ ) { if( EQUAL((const char *) (*poUDC)(i),"IDLIST") ) { IFMEString *poIDList = poSession->createString(); *poIDList = GetLayerDefn()->GetName(); poUDC->setElement( i+1, *poIDList ); poSession->destroyString( poIDList ); break; } } if( i == poUDC->entries() ) { poUDC->append( "IDLIST" ); poUDC->append( GetLayerDefn()->GetName() ); } /* -------------------------------------------------------------------- */ /* Update the macros for source information, if needed. */ /* -------------------------------------------------------------------- */ if( m_poFilterGeom != NULL ) { const char *pszDirective = "RUNTIME_MACROS"; if( !poUDC->contains(pszDirective) ) { poUDC->append(pszDirective); poUDC->append(""); } for( i = 0; i < poUDC->entries(); i++ ) { if( EQUAL((const char *) (*poUDC)(i),pszDirective) ) { IFMEString *poMacroValue = poSession->createString(); char szSEARCH_ENVELOPE[1024]; OGREnvelope oEnvelope; poUDC->getElement( i+1, *poMacroValue ); m_poFilterGeom->getEnvelope( &oEnvelope ); if( STARTS_WITH_CI(pszReaderName, "SDE") ) { sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinX ); SetMacro( poMacroValue, "_SDE3MINX", szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinY ); SetMacro( poMacroValue, "_SDE3MINY", szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxX ); SetMacro( poMacroValue, "_SDE3MAXX", szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxY ); SetMacro( poMacroValue, "_SDE3MAXY", szSEARCH_ENVELOPE ); } else { sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinX ); SetMacro( poMacroValue, "_ORACLE_MINX", szSEARCH_ENVELOPE); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinY ); SetMacro( poMacroValue, "_ORACLE_MINY", szSEARCH_ENVELOPE); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxX ); SetMacro( poMacroValue, "_ORACLE_MAXX", szSEARCH_ENVELOPE); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxY ); SetMacro( poMacroValue, "_ORACLE_MAXY", szSEARCH_ENVELOPE); } poUDC->setElement( i+1, *poMacroValue ); CPLDebug( "FMEOLEDB", "Update %s to:\n%s", pszDirective, poMacroValue->data() ); poSession->destroyString( poMacroValue ); break; } } } /* -------------------------------------------------------------------- */ /* Create new reader with desired constraints. */ /* -------------------------------------------------------------------- */ poReader = poSession->createReader(pszReaderName, FME_FALSE, poUDC); poSession->destroyStringArray( poUDC ); if( poReader == NULL ) { CPLFMEError( poSession, "Failed to create reader of type `%s'.\n", pszReaderName ); return FALSE; } /* -------------------------------------------------------------------- */ /* Setup constraints applied in open(). */ /* -------------------------------------------------------------------- */ IFMEStringArray *poParms = poSession->createStringArray(); if( pszAttributeFilter != NULL && strlen(pszAttributeFilter) > 0 ) { if( STARTS_WITH_CI(pszReaderName, "SDE") ) poParms->append( "WHERE" ); else poParms->append( "WHERE_CLAUSE" ); poParms->append( pszAttributeFilter ); } #ifdef notdef if( m_poFilterGeom != NULL ) { char szSEARCH_ENVELOPE[1024]; OGREnvelope oEnvelope; m_poFilterGeom->getEnvelope( &oEnvelope ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinX ); poParms->append( "SEARCH_ENVELOPE" ); poParms->append( szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MinY ); poParms->append( "SEARCH_ENVELOPE" ); poParms->append( szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxX ); poParms->append( "SEARCH_ENVELOPE" ); poParms->append( szSEARCH_ENVELOPE ); sprintf( szSEARCH_ENVELOPE, "%.16f", oEnvelope.MaxY ); poParms->append( "SEARCH_ENVELOPE" ); poParms->append( szSEARCH_ENVELOPE ); } #endif for( i = 0; i < poParms->entries(); i++ ) { CPLDebug( "FMEOLEDB", "openParms[%d] = %s", i, (const char *) (*poParms)(i) ); } /* -------------------------------------------------------------------- */ /* Now try to open the dataset. */ /* -------------------------------------------------------------------- */ err = poReader->open( pszDataset, *poParms ); if( err ) { CPLFMEError( poSession, "Failed to open dataset `%s' with reader of type `%s'.\n", pszDataset, pszReaderName ); return FALSE; } poSession->destroyStringArray( poParms ); return TRUE; }