document_to_graph::document_to_graph(k3d::idocument& Document) :
m_document(Document),
m_include_materials(init_owner(*this) + init_name("include_materials") + init_label("") + init_description("") + init_value(false)),
m_include_painters(init_owner(*this) + init_name("include_painters") + init_label("") + init_description("") + init_value(false))
{
m_include_materials.changed_signal().connect(k3d::hint::converter<
k3d::hint::convert<k3d::hint::any, k3d::hint::graph_topology_changed> >(make_update_graph_slot()));
m_include_painters.changed_signal().connect(k3d::hint::converter<
k3d::hint::convert<k3d::hint::any, k3d::hint::graph_topology_changed> >(make_update_graph_slot()));
}
/*
* Create long-name directories
* @argv[1]: directory number
* @argv[2]: parent directory
*/
int main(int argc, char *argv[])
{
if (argc != 3) {
usage();
return 1;
}
names = atoi(argv[1]);
if (names > MAX_LEN3 || names <= 0) {
usage();
return 1;
}
parent_fd = open(argv[2], O_RDONLY);
if (parent_fd == -1) {
perror("open parent dir failed");
return 1;
}
init_name();
create_dirs(names);
return 0;
}
void parsing_objects(int fd, char *object, t_env *rt)
{
char *line;
char **tab;
int tmp;
tmp = 0;
init_name(rt, object);
while (get_next_line(fd, &line) > 0 && line[0])
{
tmp = 1;
tab = ft_strsplit(line, ' ');
if ((ft_strcmp(tab[0], "radius") && ft_strcmp(tab[0], "pos") &&
ft_strcmp(tab[0], "color") && ft_strcmp(tab[0], "angle") &&
ft_strcmp(tab[0], "a") && ft_strcmp(tab[0], "b") &&
ft_strcmp(tab[0], "c") && ft_strcmp(tab[0], "material") &&
ft_strcmp(tab[0], "separation")) ||
!tab[2])
ft_exit("\033[31mMissing parameter for an object\n");
parsing_options(tab, rt, rt->i_obj);
parsing_options2(tab, rt, rt->i_obj);
tab_free(tab);
ft_strdel(&line);
}
if (tmp)
ft_strdel(&line);
rt->i_obj++;
}
node::node(iplugin_factory& Factory, idocument& Document) :
property_collection(),
m_factory(Factory),
m_document(Document),
m_name(init_owner(*this) + init_name("name") + init_label(_("Name")) + init_description(_("Assign a human-readable name to identify this node.")) + init_value<std::string>(""))
{
m_deleted_signal.connect(sigc::mem_fun(*this, &node::on_deleted));
m_name.changed_signal().connect(sigc::hide(m_name_changed_signal.make_slot()));
}
//--------- Begin of function Firm::init --------//
//
// It will initialize vars, and set the world matrix.
// Before calling init(), firm_recno should be set
//
// Note : it will set world matrix regardless the existing location content,
// so you must ensure that the location is clean by calling
// world.zoom_matrix->add_firm_test()
//
// <int> xLoc, yLoc = the location of firm in the world map
// <int> nationRecno = the recno of nation which build this firm
// <int> firmId = id(type) of the firm
// [char*] buildCode = the build code of the firm, no need to give if the firm just have one build type
// [short] builderRecno = recno of the builder unit
//
void Firm::init(int xLoc, int yLoc, int nationRecno, int firmId, char* buildCode, short builderRecno)
{
FirmInfo* firmInfo = firm_res[firmId];
firm_id = firmId;
if( buildCode )
firm_build_id = firmInfo->get_build_id(buildCode);
if( !buildCode || !firm_build_id ) // some buildings like human offensive structures do not have different buildings for different nationality, so firm_build_id will be 0
firm_build_id = firmInfo->first_build_id;
//----------- set vars -------------//
nation_recno = nationRecno;
setup_date = info.game_date;
//----- set the firm's absolute positions on the map -----//
FirmBuild* firmBuild = firm_res.get_build(firm_build_id);
FirmBitmap* firmBitmap;
race_id = firmInfo->get_race_id(buildCode);
if( !race_id ) // some firms like human offensive structures do not have race_id.
race_id = nation_array[nation_recno]->race_id;
err_when( is_human() == (firmId >= FIRM_LAIR && firmId <= FIRM_MAGIC) ); // error when a human attempts to build a monster firm or a mosnter attempts to build a human firm
loc_x1 = xLoc;
loc_y1 = yLoc;
loc_x2 = loc_x1 + firmBuild->loc_width - 1;
loc_y2 = loc_y1 + firmBuild->loc_height - 1;
center_x = (loc_x1 + loc_x2) / 2;
center_y = (loc_y1 + loc_y2) / 2;
region_id = world.get_region_id( center_x, center_y );
// get the height of the top left corner
// altitude = world.get_corner(xLoc, yLoc)->get_altitude();
altitude = world.get_corner(loc_x2+1, loc_y2+1)->get_altitude();
abs_x1 = world.zoom_matrix->calc_abs_x(xLoc * LOCATE_WIDTH,
yLoc * LOCATE_HEIGHT, altitude) + firmBuild->min_offset_x;
abs_y1 = world.zoom_matrix->calc_abs_y(xLoc * LOCATE_WIDTH,
yLoc * LOCATE_HEIGHT, altitude) + firmBuild->min_offset_y;
abs_x2 = abs_x1 + firmBuild->max_bitmap_width - 1;
abs_y2 = abs_y1 + firmBuild->max_bitmap_height - 1;
//--------- set animation frame vars ---------//
int bitmapCount;
int firstBitmap;
int frameCount = firmBuild->frame_count;
int aniPartCount = firmBuild->ani_part_count;
// ##### begin Gilbert 30/10 ######//
err_when( aniPartCount < 0 );
err_when( aniPartCount > MAX_FRAME_COUNTERS );
// firm_cur_frame = (char*) mem_add( sizeof(char) *aniPartCount);
// firm_remain_frame_delay = (char*) mem_add( sizeof(char) *aniPartCount);
// ##### end Gilbert 30/10 ######//
// even not animation_full_size will have aniPartCount = 1 (set in firmres.cpp)
for (int i = 0; i < aniPartCount ; i++)
{
firm_cur_frame[i] = 1;
if( firmBuild->animate_full_size )
// animate_full_size only supports animation of looping
// it does not support random animation and in fact
// it is now only used for no animation buildings
firm_remain_frame_delay[i] = (char) firmBuild->frame_delay(1);
else
{
// not animate_full_size supports animation of looping and
// random animation and partial animation
// unlike the animate_full_size animation, it search starting
// from the 2nd frame for bitmaps (since now 1 frame may has more
// than 1 bitmap) with same animation part no. of the currently
// searching part no., i. Then assign this animation part's delay and
// set its current_frame to the first found frame
for ( int k=1; k <frameCount; k++ )
{
firstBitmap = firmBuild->first_bitmap(k+1);
bitmapCount = firmBuild->bitmap_count(k+1);
int j;
for ( j=0; j <bitmapCount; j++ )
{
firmBitmap = firm_res.get_bitmap(firstBitmap + j);
if( firmBitmap )
{
if (firmBitmap->ani_part == (i + 1))
{
firm_remain_frame_delay[i] = firmBitmap->delay;
firm_cur_frame[i] = k + 1;
break;
}
}
}
if (j < bitmapCount)
break;
}
}
}
//--------- initialize gaming vars ----------//
hit_points = (float) 0;
place_max_hit_points = firmInfo->max_hit_points;
// #### begin Gilbert 6/11 ######//
defense_attribute = firmBuild->defense_attribute;
// #### end Gilbert 6/11 ######//
//------ set construction and builder -------//
under_construction = firmInfo->buildable; // whether the firm is under construction, if the firm is not buildable it is completed in the first place
if( !under_construction ) // if this firm doesn't been to be constructed, set its hit points to the maximum
hit_points = place_max_hit_points;
if( builderRecno )
set_builder(builderRecno);
else
builder_recno = 0;
//------ update firm counter -------//
firmInfo->total_firm_count++;
if( nation_recno )
firmInfo->inc_nation_firm_count(nation_recno);
//-------------------------------------------//
if( nation_recno > 0 )
{
Nation* nationPtr = nation_array[nation_recno];
is_ai = nationPtr->is_ai();
ai_processed = 1;
//--------- increase firm counter -----------//
nationPtr->nation_firm_count++;
//-------- update last build date ------------//
nationPtr->last_build_firm_date = info.game_date;
}
else
{
is_ai = 0;
ai_processed = 0;
}
ai_status = FIRM_WITHOUT_ACTION;
ai_link_checked = 1; // check the connected firms if ai_link_checked = 0;
//--------------------------------------------//
active_link_town_recno = 0;
setup_link();
set_world_matrix();
init_name();
//----------- init AI -----------//
if( nation_recno )
nation_array[nation_recno]->add_firm_info(firm_id, firm_recno);
//-------- init derived ---------//
init_derived(); // init_derived() before set_world_matrix() so that init_derived has access to the original land info.
//-------- dynamic loading of firm bitmaps ---------//
firmBuild->load_bitmap_res();
}
void instr(SgProject* project, Rose_STL_Container<SgType*> types)
{
SgGlobal* global = SI::getFirstGlobalScope(project);
std::string prefix("rtc_ti_"); //struct prefix
std::string ti_type_str("struct rtc_typeinfo*");
SgType* ti_type = SB::buildOpaqueType(ti_type_str,global);
//Insert declarations from the typechecking library.
//void minalloc_check(unsigned long long addr)
SgFunctionDeclaration* minalloc_check_decl = SB::buildNondefiningFunctionDeclaration(
SgName("minalloc_check"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType())),
global,NULL);
SI::prependStatement(minalloc_check_decl,global);
//void typetracker_add(unsigned long long addr, struct rtc_typeinfo* ti);
SgFunctionDeclaration* typetracker_add_decl = SB::buildNondefiningFunctionDeclaration(
SgName("typetracker_add"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType()),
SB::buildInitializedName("ti",ti_type)),
global,NULL);
SI::prependStatement(typetracker_add_decl,global);
//void setBaseType(rtc_typeinfo* ti, rtc_typeinfo* base)
SgFunctionDeclaration* setBaseType_decl = SB::buildNondefiningFunctionDeclaration(
SgName("setBaseType"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("ti",ti_type),
SB::buildInitializedName("base",ti_type)),
global,NULL);
SI::prependStatement(setBaseType_decl,global);
//struct rtc_typeinfo* ti_init(const char* a, size_t sz, int c)
SgFunctionDeclaration* ti_init_decl = SB::buildNondefiningFunctionDeclaration(
SgName("ti_init"),
ti_type,
SB::buildFunctionParameterList(
// SB::buildInitializedName("a",SB::buildPointerType(SB::buildConstType(SB::buildCharType()))),
SB::buildInitializedName("a",SB::buildPointerType(SB::buildCharType())),
// SB::buildInitializedName("sz", SB::buildOpaqueType("size_t",global)),
SB::buildInitializedName("sz", SB::buildLongLongType()),
SB::buildInitializedName("c", SB::buildIntType())),
global,NULL);
SI::prependStatement(ti_init_decl,global);
//void traverseAndPrint()
SgFunctionDeclaration* traverseAndPrint_decl = SB::buildNondefiningFunctionDeclaration(
SgName("traverseAndPrint"),SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(traverseAndPrint_decl,global);
//non-defining declaration of rtc_init_typeinfo
SgName init_name("rtc_init_typeinfo");
SgFunctionDeclaration* init_nondef = SB::buildNondefiningFunctionDeclaration(init_name,SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(init_nondef,global);
//call to rtc_init_typeinfo placed in main function.
SgFunctionDeclaration* maindecl = SI::findMain(project);
SgExprStatement* initcall = SB::buildFunctionCallStmt(init_name,SgTypeVoid::createType(),NULL,maindecl->get_definition());
maindecl->get_definition()->prepend_statement(initcall);
//defining declaration of rtc_init_typeinfo
SgFunctionDeclaration* init_definingDecl = new SgFunctionDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_name,init_nondef->get_type(),NULL);
init_definingDecl->set_firstNondefiningDeclaration(init_nondef);
SgFunctionDefinition* init_definition = new SgFunctionDefinition(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_definingDecl,SB::buildBasicBlock());
init_definingDecl->set_definition(init_definition);
SI::appendStatement(init_definingDecl,global);
std::vector<std::string> lst;
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string nameStr = prefix + Util::getNameForType(ptr).getString();
if(!contains(lst,nameStr))
{
SgVariableDeclaration* decl = SB::buildVariableDeclaration(nameStr,ti_type,NULL,global);
SI::prependStatement(decl,global);
lst.push_back(nameStr);
}
}
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string typeNameStr = Util::getNameForType(ptr).getString();
std::string structNameStr = prefix + Util::getNameForType(ptr).getString();
if(contains(lst,structNameStr))
{
SgExpression* lhs;
SgExpression* rhs;
//In case of an anonymous struct or union, we create a local, named version of the declaration so we can know its size.
SgClassDeclaration* altDecl = NULL;
if(isSgNamedType(ptr) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration())->get_isUnNamed())
{
SgClassDeclaration* originalDecl = isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()->get_definingDeclaration());
SgName altDecl_name(typeNameStr + "_def");
altDecl = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
SgClassDefinition* altDecl_definition = SB::buildClassDefinition(altDecl);
SgDeclarationStatementPtrList originalMembers = originalDecl->get_definition()->get_members();
for(SgDeclarationStatementPtrList::iterator it = originalMembers.begin(); it != originalMembers.end(); it++)
{
SgDeclarationStatement* member = *it;
SgDeclarationStatement* membercpy = isSgDeclarationStatement(SI::copyStatement(member));
altDecl_definition->append_member(membercpy);
}
SgClassDeclaration* altDecl_nondef = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
altDecl_nondef->set_scope(global);
altDecl->set_scope(global);
altDecl->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl_nondef->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl->set_definingDeclaration(altDecl);
altDecl_nondef->set_definingDeclaration(altDecl);
SgClassType* altDecl_ct = SgClassType::createType(altDecl_nondef);
altDecl->set_type(altDecl_ct);
altDecl_nondef->set_type(altDecl_ct);
altDecl->set_isUnNamed(false);
altDecl_nondef->set_isUnNamed(false);
altDecl_nondef->set_forward(true);
SgSymbol* sym = new SgClassSymbol(altDecl_nondef);
global->insert_symbol(altDecl_name, sym);
altDecl->set_linkage("C");
altDecl_nondef->set_linkage("C");
ROSE_ASSERT(sym && sym->get_symbol_basis() == altDecl_nondef);
ROSE_ASSERT(altDecl->get_definingDeclaration() == altDecl);
ROSE_ASSERT(altDecl->get_firstNondefiningDeclaration() == altDecl_nondef);
ROSE_ASSERT(altDecl->search_for_symbol_from_symbol_table() == sym);
ROSE_ASSERT(altDecl->get_definition() == altDecl_definition);
ROSE_ASSERT(altDecl->get_scope() == global && altDecl->get_scope() == altDecl_nondef->get_scope());
ROSE_ASSERT(altDecl_ct->get_declaration() == altDecl_nondef);
//For some reason, this is not working...
//global->append_statement(altDecl);
//global->prepend_statement(altDecl_nondef);
//SI::setOneSourcePositionForTransformation(altDecl);
//SI::setOneSourcePositionForTransformation(altDecl_nondef);
}
SgType* baseType;
if(isSgPointerType(ptr))
baseType = ptr->dereference();
else
baseType = ptr->findBaseType();
baseType = baseType->stripTypedefsAndModifiers();
if(baseType == NULL || baseType == ptr)
{
//In this case, there is no base type.
rhs = SB::buildFunctionCallExp(SgName("ti_init"),SgTypeVoid::createType(),SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
}
else
{
//The type has a base type.
std::string baseStructNameStr = prefix + Util::getNameForType(baseType).getString();
rhs = SB::buildFunctionCallExp(SgName("ti_init"),ti_type,SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
SgExprStatement* set_BT = SB::buildFunctionCallStmt(SgName("setBaseType"),ti_type,SB::buildExprListExp(
SB::buildVarRefExp(structNameStr),
SB::buildVarRefExp(baseStructNameStr)),
init_definition);
init_definition->append_statement(set_BT);
}
lhs = SB::buildVarRefExp(structNameStr);
SgExprStatement* assignstmt = SB::buildAssignStatement(lhs,rhs);
init_definition->prepend_statement(assignstmt);
std::remove(lst.begin(),lst.end(),structNameStr);
}
}
}
