struct result_queue* result_queue_new(GMainContext* context,
result_queue_handler_f handler,
gpointer userdata)
{
struct result_queue *queue;
g_return_val_if_fail(handler!=NULL, NULL);
queue = (struct result_queue *)
g_source_new(&source_functions,
sizeof(struct result_queue));
queue->async_queue=g_async_queue_new();
queue->handler=handler;
queue->main_context=context;
queue->userdata=userdata;
g_source_set_callback(SOURCE(queue),
source_callback,
NULL/*data*/,
NULL/*notify*/);
g_source_attach(SOURCE(queue), context);
result_queue_counter++;
return queue;
}
Vertices *
GenTree(int nVertex)
{
int i;
int weight;
Vertices * vertex;
Vertices * graph;
Edges * edge;
graph = NewVertex();
NEXT_VERTEX(graph) = graph;
for(i = 1; i < nVertex; i++)
{
vertex = NewVertex();
edge = NewEdge();
/*
* The newly created vertex has one edge ...
*/
EDGES(vertex) = edge;
/*
* ... which is connected to the graph so far generated. The connection
* point in the graph is picked at random.
*/
VERTEX(edge) = PickVertex(graph, random() % i);
weight = GET_WEIGHT;
WEIGHT(edge) = weight;
SOURCE(edge) = vertex;
/*
* Link the new vertex into the graph.
*/
NEXT_VERTEX(vertex) = NEXT_VERTEX(graph);
NEXT_VERTEX(graph) = vertex;
/*
* Add an edge to the vertex randomly picked as the connection point.
*/
edge = NewEdge();
WEIGHT(edge) = weight;
SOURCE(edge) = VERTEX(EDGES(vertex));
VERTEX(edge) = vertex;
NEXT_EDGE(edge) = EDGES(VERTEX(EDGES(vertex)));
EDGES(VERTEX(EDGES(vertex))) = edge;
}
return(graph);
}
/**
* Tries to parse a document containing multiple tags
*/
static void test_xml_parse_document_1() {
SOURCE(source, ""
"<Parent>\n"
"\t<Child>\n"
"\t\tFirst content\n"
"\t</Child>\n"
"\t<Child>\n"
"\t\tSecond content\n"
"\t</Child>\n"
"</Parent>\n"
);
struct xml_document* document = xml_parse_document(source, strlen(source));
assert_that(document, "Could not parse document");
struct xml_node* root = xml_document_root(document);
// assert_that(string_equals(xml_node_name(root), "Parent"), "root node name must be `Parent'");
assert_that(2 == xml_node_children(root), "root must have two children");
struct xml_node* first_child = xml_node_child(root, 0);
struct xml_node* second_child = xml_node_child(root, 1);
assert_that(first_child && second_child, "Failed retrieving the children of root");
struct xml_node* third_child = xml_node_child(root, 2);
assert_that(!third_child, "root has a third child where non should be");
// assert_that(string_equals(xml_node_name(first_child), "Child"), "first_child node name must be `Child'");
// assert_that(string_equals(xml_node_content(first_child), "First content"), "first_child node content must be `First content'");
// assert_that(string_equals(xml_node_name(second_child), "Child"), "second_child node name must be `Child'");
// assert_that(string_equals(xml_node_content(second_child), "Second content"), "second_child node content must be `tSecond content'");
xml_document_free(document, true);
}
static CARD32*
BitmapScanline(
CARD32 *src, CARD32 *dest,
int count, int skipleft )
{
while(count >= 4) {
DEST(0) = SOURCE(0);
DEST(1) = SOURCE(1);
DEST(2) = SOURCE(2);
DEST(3) = SOURCE(3);
count -= 4;
src += 4;
#ifndef FIXEDBASE
dest += 4;
#endif
}
if(!count) return dest;
DEST(0) = SOURCE(0);
if(count == 1) RETURN(1);
DEST(1) = SOURCE(1);
if(count == 2) RETURN(2);
DEST(2) = SOURCE(2);
RETURN(3);
}
Term YAPListTerm::cdr() {
Term to = gt();
if (IsPairTerm(to))
return (TailOfTerm(to));
else if (to == TermNil)
return TermNil;
/* error */
throw YAPError(SOURCE(), TYPE_ERROR_LIST, to, "");
}
Term YAPListTerm::car() {
Term to = gt();
if (IsPairTerm(to))
return (HeadOfTerm(to));
else {
throw YAPError(SOURCE(), TYPE_ERROR_LIST, to, "");
return TermUnique;
}
}
void
PrintNeighbors(Vertices * vertex)
{
Edges * edge;
edge = EDGES(vertex);
while(edge != NULL)
{
printf(" %d(%d)[%d]", ID(VERTEX(edge)), WEIGHT(edge), ID(SOURCE(edge)));
edge = NEXT_EDGE(edge);
}
}
Term YAPTerm::getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term tf = 0;
Term t0 = gt();
if (IsApplTerm(t0)) {
if (i > ArityOfFunctor(FunctorOfTerm(t0)))
throw YAPError(SOURCE(), DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
tf = (ArgOfTerm(i, t0));
} else if (IsPairTerm(t0)) {
if (i == 1)
tf = (HeadOfTerm(t0));
else if (i == 2)
tf = (TailOfTerm(t0));
else
throw YAPError(SOURCE(), DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
} else {
throw YAPError(SOURCE(), TYPE_ERROR_COMPOUND, t0, "t0.getArg()");
}
RECOVER_MACHINE_REGS();
return tf;
}
void result_queue_delete(struct result_queue* queue)
{
GSource *source;
g_return_if_fail(queue);
source=SOURCE(queue);
g_source_destroy(source);
g_source_unref(source);
/* resources are only released by source_finalize(),
* caled by g_source_unref() whenever it thinks
* there are no more references to the source.
*/
}
void
Connect(Vertices * vertex1, Vertices * vertex2)
{
int weight;
Edges * edge;
weight = GET_WEIGHT;
edge = NewEdge();
WEIGHT(edge) = weight;
SOURCE(edge) = vertex1;
VERTEX(edge) = vertex2;
NEXT_EDGE(edge) = EDGES(vertex1);
EDGES(vertex1) = edge;
edge = NewEdge();
WEIGHT(edge) = weight;
SOURCE(edge) = vertex2;
VERTEX(edge) = vertex1;
NEXT_EDGE(edge) = EDGES(vertex2);
EDGES(vertex2) = edge;
}
YAPPredicate::YAPPredicate(Term &t, Term &tmod, CELL *&ts, const char *pname) {
Term t0 = t;
ap = nullptr;
restart:
if (IsVarTerm(t)) {
throw YAPError(SOURCE(), INSTANTIATION_ERROR, t0, pname);
} else if (IsAtomTerm(t)) {
ap = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t), tmod));
ts = nullptr;
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
ts = nullptr;
ap = Yap_FindLUIntKey(IntegerOfTerm(t));
} else if (IsPairTerm(t)) {
t = Yap_MkApplTerm(FunctorCsult, 1, &t);
goto restart;
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE,
Yap_TermToIndicator(t, tmod), pname);
}
if (fun == FunctorModule) {
tmod = ArgOfTerm(1, t);
if (IsVarTerm(tmod)) {
throw YAPError(SOURCE(), INSTANTIATION_ERROR, t0, pname);
}
if (!IsAtomTerm(tmod)) {
throw YAPError(SOURCE(), TYPE_ERROR_ATOM, t0, pname);
}
t = ArgOfTerm(2, t);
goto restart;
}
ap = RepPredProp(Yap_GetPredPropByFunc(fun, tmod));
ts = RepAppl(t) + 1;
} else {
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE, t0, pname);
}
}
std::vector<YAPTerm> YAPPairTerm::listToVector() {
Term *tailp;
Term t1 = gt();
Int l = Yap_SkipList(&t1, &tailp);
if (l < 0) {
throw YAPError(SOURCE(), TYPE_ERROR_LIST, (t), nullptr);
}
std::vector<YAPTerm> o = *new std::vector<YAPTerm>(l);
int i = 0;
Term t = gt();
while (t != TermNil) {
o[i++] = YAPTerm(HeadOfTerm(t));
t = TailOfTerm(t);
}
return o;
}
/**
* Tries to parse a simple document containing only one tag
*/
static void test_xml_parse_document_0() {
SOURCE(source, "<Hello>World</Hello>");
// uint8_t* source = malloc((1 + strlen("<Hello>World</Hello>")) * sizeof(uint8_t));
// { char const* content_string = "<Hello>World</Hello>";
// memcpy(source, content_string, strlen("<Hello>World</Hello>") + 1);
// }
struct xml_document* document = xml_parse_document(source, strlen(source));
assert_that(document, "Could not parse document");
struct xml_node* root = xml_document_root(document);
// assert_that(string_equals(xml_node_name(root), "Hello"), "root node name must be `Hello'");
// assert_that(string_equals(xml_node_content(root), "World"), "root node content must be `World'");
xml_document_free(document, true);
}
void
PrintMST(Vertices * graph)
{
Vertices * vertex;
assert(graph != NULL_VERTEX);
vertex = NEXT_VERTEX(graph);
while(vertex != graph)
{
printf("vertex %d to %d\n", ID(vertex), ID(SOURCE(CHOSEN_EDGE(vertex))));
vertex = NEXT_VERTEX(vertex);
}
}
/**
* Tests the eas functionality
*/
static void test_xml_parse_document_2() {
SOURCE(source, ""
"<Parent>\n"
"\t<Child>\n"
"\t\tFirst content\n"
"\t</Child>\n"
"\t<This><Is>\n"
"<A><Test>Content A</Test></A>\n"
"<B><Test>Content B</Test></B>\n"
"\t</Is></This>\n"
"\t<Child>\n"
"\t\tSecond content\n"
"\t</Child>\n"
"</Parent>\n"
);
struct xml_document* document = xml_parse_document(source, strlen(source));
assert_that(document, "Could not parse document");
struct xml_node* root = xml_document_root(document);
// assert_that(string_equals(xml_node_name(root), "Parent"), "root node name must be `Parent'");
assert_that(3 == xml_node_children(root), "root must have two children");
struct xml_node* test_a = xml_easy_child(root, "This", "Is", "A", "Test", 0);
assert_that(test_a, "Cannot find Parent/This/Is/A/Test");
// assert_that(string_equals(xml_node_content(test_a), "Content A"), "Content of Parent/This/Is/A/Test must be `Content A'");
struct xml_node* test_b = xml_easy_child(root, "This", "Is", "B", "Test", 0);
assert_that(test_b, "Cannot find Parent/This/Is/B/Test");
// assert_that(string_equals(xml_node_content(test_b), "Content B"), "Content of Parent/This/Is/B/Test must be `Content B'");
struct xml_node* test_c = xml_easy_child(root, "This", "Is", "C", "Test", 0);
assert_that(!test_c, "Must not find Parent/This/Is/C/Test because no such path exists");
struct xml_node* must_be_null = xml_easy_child(root, "Child");
assert_that(!must_be_null, "Parent/Child cannot be a valid expression, because there are two children named `Child' in `Parent'");
// uint8_t* name_is = xml_easy_name(xml_easy_child(root, "This", "Is", 0));
// assert_that(!strcmp(name_is, "Is"), "Name of Parent/This/Is must be `Is'");
// free(name_is);
// uint8_t* content_a = xml_easy_content(test_a);
// assert_that(!strcmp(content_a, "Content A"), "Content of Parent/This/Is/A/Test must be `Content A'");
// free(content_a);
xml_document_free(document, true);
}
Term &YAPTerm::operator[](arity_t i) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
Term *tf = nullptr;
if (IsApplTerm(t0)) {
// Functor f = FunctorOfTerm(t0);
// if (IsExtensionFunctor(f))
// return 0;
tf = RepAppl(t0) + (i + 1);
} else if (IsPairTerm(t0)) {
if (i == 0)
tf = RepPair(t0);
else if (i == 1)
tf = RepPair(t0) + 1;
RECOVER_MACHINE_REGS();
} else {
throw YAPError(SOURCE(), TYPE_ERROR_COMPOUND, t0, "");
}
RECOVER_MACHINE_REGS();
return *tf;
}
/*
====================================================================
Load terrain types, weather information and hex tile icons.
====================================================================
*/
int terrain_load( char *fname )
{
int i, j, k;
PData *pd, *sub, *subsub, *subsubsub;
List *entries, *flags;
char path[512], transitionPath[512];
char *flag, *str;
char *domain = 0;
int count;
/* log info */
int log_dot_limit = 40; /* maximum of dots */
char log_str[128];
sprintf( transitionPath, "Scenario/%s", fname );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( pd = parser_read_file( fname, path ) ) == 0 ) goto parser_failure;
// domain = determine_domain(pd, fname);
// locale_load_domain(domain, 0/*FIXME*/);
/* get weather */
if ( !parser_get_entries( pd, "weather", &entries ) ) goto parser_failure;
weather_type_count = entries->count;
weather_types = calloc( weather_type_count, sizeof( Weather_Type ) );
list_reset( entries ); i = 0;
while ( ( sub = list_next( entries ) ) ) {
weather_types[i].id = strdup( sub->name );
// if ( !parser_get_localized_string( sub, "name", domain, &weather_types[i].name ) ) goto parser_failure;
if ( !parser_get_value( sub, "name", &str, 0 ) ) goto parser_failure;
weather_types[i].name = strdup( str );
if ( !parser_get_value( sub, "ground_cond", &str, 0 ) ) goto parser_failure;
weather_types[i].ground_conditions = strdup( str );
if ( !parser_get_values( sub, "flags", &flags ) ) goto parser_failure;
list_reset( flags );
while ( ( flag = list_next( flags ) ) )
weather_types[i].flags |= check_flag( flag, fct_terrain );
i++;
}
/* hex tile geometry */
if ( !parser_get_int( pd, "hex_width", &hex_w ) ) goto parser_failure;
if ( !parser_get_int( pd, "hex_height", &hex_h ) ) goto parser_failure;
if ( !parser_get_int( pd, "hex_x_offset", &hex_x_offset ) ) goto parser_failure;
if ( !parser_get_int( pd, "hex_y_offset", &hex_y_offset ) ) goto parser_failure;
/* terrain icons */
terrain_icons = calloc( 1, sizeof( Terrain_Icons ) );
if ( !parser_get_value( pd, "fog", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->fog = load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ) ) == 0 ) goto failure;
if ( !parser_get_value( pd, "danger", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->danger = load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ) ) == 0 ) goto failure;
if ( !parser_get_value( pd, "grid", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->grid = load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ) ) == 0 ) goto failure;
if ( !parser_get_value( pd, "frame", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->select = load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ) ) == 0 ) goto failure;
if ( !parser_get_value( pd, "crosshair", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->cross = anim_create( load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ), 1000/config.anim_speed, hex_w, hex_h, sdl.screen, 0, 0 ) ) == 0 )
goto failure;
anim_hide( terrain_icons->cross, 1 );
if ( !parser_get_value( pd, "explosion", &str, 0 ) ) goto parser_failure;
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_icons->expl1 = anim_create( load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ), 50/config.anim_speed, hex_w, hex_h, sdl.screen, 0, 0 ) ) == 0 )
goto failure;
anim_hide( terrain_icons->expl1, 1 );
if ( ( terrain_icons->expl2 = anim_create( load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ), 50/config.anim_speed, hex_w, hex_h, sdl.screen, 0, 0 ) ) == 0 )
goto failure;
anim_hide( terrain_icons->expl2, 1 );
/* terrain sounds */
#ifdef WITH_SOUND
if ( parser_get_value( pd, "explosion_sound", &str, 0 ) )
{
snprintf( transitionPath, 512, "Sound/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
terrain_icons->wav_expl = wav_load( path, 2 );
}
if ( parser_get_value( pd, "select_sound", &str, 0 ) )
{
snprintf( transitionPath, 512, "Sound/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
terrain_icons->wav_select = wav_load( path, 1 );
}
#endif
/* terrain data image columns */
if ( !parser_get_int( pd, "terrain_columns", &terrain_columns ) ) goto parser_failure;
/* terrain data image rows */
if ( !parser_get_int( pd, "terrain_rows", &terrain_rows ) ) goto parser_failure;
/* each ground condition type got its own image -- if it's named 'default' we
point towards the image of weather_type 0 */
terrain_images = calloc( 1, sizeof( Terrain_Images ) );
terrain_images->images = calloc( weather_type_count / 4, sizeof( SDL_Surface* ) );
for ( j = 0; j < weather_type_count / 4; j++ ) {
terrain_images->ground_conditions = strdup( weather_types[4*j].ground_conditions );
sprintf( path, "image/%s", weather_types[4*j].ground_conditions );
if ( !parser_get_value( pd, path, &str, 0 ) ) goto parser_failure;
if ( STRCMP( "default", str ) && j > 0 ) {
/* just a pointer */
terrain_images->images[j] = terrain_images->images[0];
}
else {
sprintf( transitionPath, "Graphics/%s", str );
search_file_name_exact( path, transitionPath, config.mod_name );
if ( ( terrain_images->images[j] = load_surf( path, SDL_SWSURFACE, 0, 0, 0, 0 ) ) == 0 ) goto parser_failure;
SDL_SetColorKey( terrain_images->images[j], SDL_SRCCOLORKEY,
get_pixel( terrain_images->images[j], 0, 0 ) );
}
}
/* fog image */
terrain_images->images_fogged = calloc( weather_type_count / 4, sizeof( SDL_Surface* ) );
for ( j = 0; j < weather_type_count / 4; j++ ) {
if ( terrain_images->images[j] == terrain_images->images[0] && j > 0 ) {
/* just a pointer */
terrain_images->images_fogged[j] = terrain_images->images_fogged[0];
}
else {
terrain_images->images_fogged[j] = create_surf( terrain_images->images[j]->w, terrain_images->images[j]->h, SDL_SWSURFACE );
FULL_DEST( terrain_images->images_fogged[j] );
FULL_SOURCE( terrain_images->images[j] );
blit_surf();
count = terrain_images->images[j]->w / hex_w;
for ( i = 0; i < terrain_rows; i++ )
for ( k = 0; k < terrain_columns; k++ ) {
DEST( terrain_images->images_fogged[j], k * hex_w, i * hex_h, hex_w, hex_h );
SOURCE( terrain_icons->fog, 0, 0 );
alpha_blit_surf( FOG_ALPHA );
}
SDL_SetColorKey( terrain_images->images_fogged[j], SDL_SRCCOLORKEY, get_pixel( terrain_images->images_fogged[j], 0, 0 ) );
}
}
/* terrain types */
if ( !parser_get_entries( pd, "terrain", &entries ) ) goto parser_failure;
terrain_type_count = entries->count;
terrain_types = calloc( terrain_type_count, sizeof( Terrain_Type ) );
list_reset( entries ); i = 0;
while ( ( sub = list_next( entries ) ) ) {
/* id */
terrain_types[i].id = sub->name[0];
/* name */
if ( !parser_get_localized_string( sub, "name", domain, &terrain_types[i].name ) ) goto parser_failure;
/* spot cost */
terrain_types[i].spt = calloc( weather_type_count, sizeof( int ) );
if ( !parser_get_pdata( sub, "spot_cost", &subsub ) ) goto parser_failure;
for ( j = 0; j < weather_type_count; j++ )
if ( !parser_get_int( subsub, weather_types[j].id, &terrain_types[i].spt[j] ) ) goto parser_failure;
/* image */
terrain_types[i].images = terrain_images->images;
/* fog image */
terrain_types[i].images_fogged = terrain_images->images_fogged;
/* mov cost */
terrain_types[i].mov = calloc( mov_type_count * weather_type_count, sizeof( int ) );
if ( !parser_get_pdata( sub, "move_cost", &subsub ) ) goto parser_failure;
for ( k = 0; k < mov_type_count; k++ ) {
if ( !parser_get_pdata( subsub, mov_types[k].id, &subsubsub ) ) goto parser_failure;
for ( j = 0; j < weather_type_count; j++ ) {
if ( !parser_get_value( subsubsub, weather_types[j].id, &str, 0 ) ) goto parser_failure;
if ( str[0] == 'X' )
terrain_types[i].mov[j + k * weather_type_count] = 0; /* impassable */
else
if ( str[0] == 'A' )
terrain_types[i].mov[j + k * weather_type_count] = -1; /* costs all */
else
terrain_types[i].mov[j + k * weather_type_count] = atoi( str ); /* normal cost */
}
}
/* entrenchment */
if ( !parser_get_int( sub, "min_entr", &terrain_types[i].min_entr ) ) goto parser_failure;
if ( !parser_get_int( sub, "max_entr", &terrain_types[i].max_entr ) ) goto parser_failure;
/* initiative modification */
if ( !parser_get_int( sub, "max_init", &terrain_types[i].max_ini ) ) goto parser_failure;
/* flags */
terrain_types[i].flags = calloc( weather_type_count, sizeof( int ) );
if ( !parser_get_pdata( sub, "flags", &subsub ) ) goto parser_failure;
for ( j = 0; j < weather_type_count; j++ ) {
if ( !parser_get_values( subsub, weather_types[j].id, &flags ) ) goto parser_failure;
list_reset( flags );
while ( ( flag = list_next( flags ) ) )
terrain_types[i].flags[j] |= check_flag( flag, fct_terrain );
}
/* next terrain */
i++;
/* LOG */
strcpy( log_str, " [ ]" );
for ( k = 0; k < i * log_dot_limit / entries->count; k++ )
log_str[3 + k] = '*';
write_text( log_font, sdl.screen, log_x, log_y, log_str, 255 );
SDL_UpdateRect( sdl.screen, log_font->last_x, log_font->last_y, log_font->last_width, log_font->last_height );
}
parser_free( &pd );
/* LOG */
write_line( sdl.screen, log_font, log_str, log_x, &log_y ); refresh_screen( 0, 0, 0, 0 );
free(domain);
return 1;
parser_failure:
fprintf( stderr, "%s\n", parser_get_error() );
failure:
terrain_delete();
if ( pd ) parser_free( &pd );
free(domain);
printf(tr("If data seems to be missing, please re-run the converter lgc-pg.\n"));
return 0;
}
static int
compact_effect_edge(effect_t *effect, IPA_cgraph_edge_t *edge,
IPA_cgraph_edgelist_e edge_type,
int issrc, int retain_oldeffect, int update)
{
IPA_cgraph_node_t *n_src = NULL;
IPA_cgraph_node_t *n_dst = NULL;
IPA_cgraph_edgelist_e n_type = 0;
IPA_cgraph_edge_data_t n_data;
int n_skew;
int t1, z1, s1, t2, z2, s2;
int ts1, ss1, ts2, ss2;
int compaction_action;
compaction_action = NO_EFFECT;
/* All addr effects are from initial effects and
should be kept */
if (effect->edge_type == ASSIGN_ADDR)
{
/* This is not really an error but reaching this is
an inefficiency */
assert(0);
return 1;
}
/* AA and DA edges are added during initial effect
generation only */
if ((edge_type == ASSIGN_ADDR
/* FIXTEST */
&& !(issrc && effect->edge_type == DEREF_ASSIGN)
) || edge_type == DEREF_ASSIGN)
{
/* do nothing */
#if DB_EFF > 1
printf("AD/AA : no action\n");
#endif
return 0;
}
/* Override if src is PARAM and we're handling the
* dst of an DEREF_ASSIGN */
if (!issrc && IPA_FLAG_ISSET(edge->src_elist->node->flags,
IPA_CG_NODE_FLAGS_PARAM))
{
#if DB_EFF > 1
printf("FORCE - ");
#endif
retain_oldeffect = 1;
}
t1 = TARGET(effect->edata);
ts1 = TGTSTR(effect->edata);
z1 = SIZE(effect->edata);
ss1 = SRCSTR(effect->edata);
s1 = SOURCE(effect->edata);
n_skew = effect->skew;
t2 = TARGET(edge->data);
ts2 = TGTSTR(edge->data);
z2 = SIZE(edge->data);
ss2 = SRCSTR(edge->data);
s2 = SOURCE(edge->data);
switch(effect->edge_type)
{
/***************** ASSIGN ********************/
case ASSIGN:
assert(issrc);
n_src = edge->src_elist->node;
n_dst = effect->dst;
if (ss1 != 0 || ts2 != 0)
{
/* Meshing stride, retain effect */
compaction_action = HAS_EFFECT;
retain_oldeffect = 1;
break;
}
switch(edge_type)
{
case ASSIGN:
n_type = ASSIGN;
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("A-A : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z1, z2 - (s1-t2));
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2 + (s1-t2);
}
else if (BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("A-A : new 2");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1 + (t2-s1);
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z2, z1 - (t2-s1));
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
}
#if DB_EFF > 1
else
printf("A-A : none");
#endif
break;
case SKEW:
n_type = SKEW;
if (BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("A-K : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1 + (t2-s1);
TGTSTR(n_data) = ts1;
SIZE(n_data) = z2;
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
}
#if DB_EFF > 1
else
printf("A-K : none");
#endif
break;
case ASSIGN_DEREF:
n_type = ASSIGN_DEREF;
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("A-AD : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z1, z2-(s1-t2));
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
n_skew += (s1 - t2);
}
else if (BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("A-AD : new 2");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1 + (t2-s1);
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z2, z1 - (t2-s1));;
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
}
#if DB_EFF > 1
else
printf("A-AD : none");
#endif
break;
default:
assert(0);
}
break;
case SKEW:
/***************** SKEW ********************/
assert(issrc);
n_src = edge->src_elist->node;
n_dst = effect->dst;
if (ss1 != 0 || ts2 != 0)
{
/* Meshing stride, retain effect */
compaction_action = HAS_EFFECT;
retain_oldeffect = 1;
break;
}
switch(edge_type)
{
case ASSIGN:
n_type = SKEW;
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("K-A : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = z1;
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2 + (s1 - t2);
}
#if DB_EFF > 1
else
printf("K-A : none");
#endif
break;
case SKEW:
n_type = SKEW;
if (s1 == t2)
{
#if DB_EFF > 1
printf("K-K : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = (z1 + z2);
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
}
#if DB_EFF > 1
else
printf("K-K : none");
#endif
break;
case ASSIGN_DEREF:
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("K-AD : retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("K-AD : none");
#endif
retain_oldeffect = 1;
break;
default:
assert(0);
}
break;
case ASSIGN_DEREF:
/***************** ASSIGN_DEREF ********************/
assert(issrc);
n_src = edge->src_elist->node;
n_dst = effect->dst;
if (ss1 != 0 || ts2 != 0)
{
/* Meshing stride, retain effect */
compaction_action = HAS_EFFECT;
retain_oldeffect = 1;
break;
}
switch(edge_type)
{
case ASSIGN:
n_type = ASSIGN_DEREF;
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("AD-A : new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = z1;
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2 + (s1-t2);
}
#if DB_EFF > 1
else
printf("AD-A : none");
#endif
break;
case SKEW:
if (s1 == t2)
{
#if DB_EFF > 1
printf("AD-K : retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("AD-K : none");
#endif
retain_oldeffect = 1;
break;
case ASSIGN_DEREF:
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("AD-AD : retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("AD-AD : none");
#endif
retain_oldeffect = 1;
break;
default:
assert(0);
}
break;
case DEREF_ASSIGN:
if (issrc)
{
/***************** (source) DEREF_ASSIGN ********************/
if (ss1 != 0 || ts2 != 0)
{
/* Meshing stride, retain effect */
compaction_action = HAS_EFFECT;
retain_oldeffect = 1;
break;
}
switch(edge_type)
{
case ASSIGN:
n_type = DEREF_ASSIGN;
n_src = edge->src_elist->node;
n_dst = effect->dst;
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-A : src new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z1, z2-(s1-t2));
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2 + (s1-t2);
}
else if (BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-A : src new 2");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = t1;
TGTSTR(n_data) = ts1;
SIZE(n_data) = MIN(z2, z1 - (t2-s1));
SRCSTR(n_data) = ss2;
SOURCE(n_data) = s2;
n_skew += (t2 - s1);
}
#if DB_EFF > 1
else
printf("DA-A : src none");
#endif
break;
case SKEW:
if (BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-K : src retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("DA-K : src none");
#endif
retain_oldeffect = 1;
break;
case ASSIGN_DEREF:
if (BOUND(t2, s1, t2 + z2 - IPA_POINTER_SIZE) ||
BOUND(s1, t2, s1 + z1 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-K/AD : src retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("DA-K/AD : src none");
#endif
retain_oldeffect = 1;
break;
/* FIXTEST */
case ASSIGN_ADDR:
if (s1 == t2)
{
#if DB_EFF > 1
printf("AD-ADDR : retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("AD-ADDR : none");
#endif
retain_oldeffect = 1;
break;
default:
assert(0);
}
}
else
{
/***************** (dest) DEREF_ASSIGN ********************/
if (ts1 != 0 || ts2 != 0)
{
/* Meshing stride, retain effect */
compaction_action = HAS_EFFECT;
retain_oldeffect = 1;
break;
}
switch(edge_type)
{
case ASSIGN:
n_type = DEREF_ASSIGN;
n_src = effect->src;
n_dst = edge->src_elist->node;
if (BOUND(t2, t1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-A : dst new 1");
#endif
compaction_action = HAS_EFFECT;
TARGET(n_data) = s2 + (t1-t2);
TGTSTR(n_data) = ss2;
SIZE(n_data) = z1;
SRCSTR(n_data) = ss1;
SOURCE(n_data) = s1;
}
#if DB_EFF > 1
else
printf("DA-A : dst none");
#endif
break;
case SKEW:
if (t1 == t2)
{
#if DB_EFF > 1
printf("DA-K : dst retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("DA-K : dst none");
#endif
retain_oldeffect = 1;
break;
case ASSIGN_DEREF:
if (BOUND(t2, t1, t2 + z2 - IPA_POINTER_SIZE))
{
#if DB_EFF > 1
printf("DA-AD : dst retain 1");
#endif
compaction_action = HAS_EFFECT;
}
#if DB_EFF > 1
else
printf("DA-AD : dst none");
#endif
retain_oldeffect = 1;
break;
default:
assert(0);
}
}
break;
default:
assert(0);
}
if (SRCSTR(n_data) != 0)
{
SOURCE(n_data) = 0;
SIZE(n_data) = IPA_POINTER_SIZE;
}
if (TGTSTR(n_data) != 0)
{
TARGET(n_data) = 0;
SIZE(n_data) = IPA_POINTER_SIZE;
}
if (compaction_action == HAS_EFFECT)
{
if (retain_oldeffect)
{
#if DB_EFF > 1
printf(" : has effect, retain old effect\n");
#endif
if (update)
SE_addedgeto_effectlist(edge);
return 1;
}
else
{
#if DB_EFF > 1
printf(" : has effect, compact\n");
#endif
if (update)
SE_addto_effectlist(n_type, n_src, n_dst, &n_data, n_skew);
return 0;
}
}
#if DB_EFF > 1
printf(" : no effect\n");
#endif
return 0;
}
static void
SE_process_effect(effect_t *effect)
{
switch(effect->edge_type)
{
case DEREF_ASSIGN:
if (SE_reflect_effect(effect, 1) == ADD_EFFECT)
{
#if 1
if (effect->skew != 0)
{
IPA_cgraph_edge_data_t data;
IPA_cgraph_node_t *tmp_node;
tmp_node = new_temp_node(local_sum, IPA_CG_NODE_FLAGS_SUMMARY);
/* SUMMARY: tmp(0) *=(z) src(s) */
TARGET(data) = 0;
TGTSTR(data) = 0;
SIZE(data) = SIZE(effect->edata);
SRCSTR(data) = SRCSTR(effect->edata);
SOURCE(data) = SOURCE(effect->edata);
SE_addto_summary(effect->edge_type,
effect->src, tmp_node, &data);
/* EFFECT : tmp(0) =+(k) dst(t) */
TARGET(data) = 0;
TGTSTR(data) = 0;
SIZE(data) = effect->skew;
SRCSTR(data) = TGTSTR(effect->edata);
SOURCE(data) = TARGET(effect->edata);
SE_addto_effectlist(SKEW, effect->dst, tmp_node, &data, 0);
break;
}
#endif
if (SE_reflect_effect(effect, 0) == ADD_EFFECT)
{
/* Effect not skipped */
SE_addto_summary(effect->edge_type, effect->src,
effect->dst, &effect->edata);
}
}
break;
case ASSIGN_DEREF:
#if 1
if (effect->skew != 0)
{
IPA_cgraph_edge_data_t data;
IPA_cgraph_node_t *tmp_node;
tmp_node = new_temp_node(local_sum, IPA_CG_NODE_FLAGS_SUMMARY);
/* SUMMARY: dst(t) =*(z) tmp(0) */
TARGET(data) = TARGET(effect->edata);
TGTSTR(data) = TGTSTR(effect->edata);
SIZE(data) = SIZE(effect->edata);
SRCSTR(data) = 0;
SOURCE(data) = 0;
SE_addto_summary(effect->edge_type,
tmp_node, effect->dst, &data);
/* EFFECT : tmp(0) =+(k) src(s) */
TARGET(data) = 0;
TGTSTR(data) = 0;
SIZE(data) = effect->skew;
SRCSTR(data) = SRCSTR(effect->edata);
SOURCE(data) = SOURCE(effect->edata);
SE_addto_effectlist(SKEW, effect->src, tmp_node, &data, 0);
break;
}
#endif
case ASSIGN:
case SKEW:
if (SE_reflect_effect(effect, 1) == ADD_EFFECT)
{
/* Effect not skipped */
SE_addto_summary(effect->edge_type, effect->src,
effect->dst, &effect->edata);
}
break;
case ASSIGN_ADDR:
SE_addto_summary(effect->edge_type, effect->src,
effect->dst, &effect->edata);
break;
default:
assert(0);
}
}
