/*
* Return STM parameters.
*/
_CALLCONV int
stm_get_parameter(const char *name, void *val)
{
if (strcmp("contention_manager", name) == 0) {
*(const char **)val = cm_names[CM];
return 1;
}
if (strcmp("design", name) == 0) {
*(const char **)val = design_names[DESIGN];
return 1;
}
if (strcmp("initial_rw_set_size", name) == 0) {
*(int *)val = RW_SET_SIZE;
return 1;
}
#if CM == CM_BACKOFF
if (strcmp("min_backoff", name) == 0) {
*(unsigned long *)val = MIN_BACKOFF;
return 1;
}
if (strcmp("max_backoff", name) == 0) {
*(unsigned long *)val = MAX_BACKOFF;
return 1;
}
#endif /* CM == CM_BACKOFF */
#if CM == CM_MODULAR
if (strcmp("vr_threshold", name) == 0) {
*(int *)val = _tinystm.vr_threshold;
return 1;
}
#endif /* CM == CM_MODULAR */
#ifdef COMPILE_FLAGS
if (strcmp("compile_flags", name) == 0) {
*(const char **)val = XSTR(COMPILE_FLAGS);
return 1;
}
#endif /* COMPILE_FLAGS */
return 0;
}
/*
****************************************************************
* Resumo de utilização do programa *
****************************************************************
*/
void
help (void)
{
fprintf
( stderr,
"%s - reinicializa o computador após um certo tempo\n"
"\n%s\n"
"\nSintaxe:\n"
"\t%s [-t <tempo>] [-p] [-v]\n"
"\t%s\n",
pgname, pgversion, pgname, reboot_nm
);
fprintf
( stderr,
"\nOpções:"
"\t-t: Espera <tempo> segundos ao invés de " XSTR (STD_TIME) "\n"
"\t-p: Reinicializa o computador imediatamente, sem mensagens\n"
"\t-v: Verboso\n"
);
exit (2);
} /* end help */
static int
indirect_data (rtx sym_ref)
{
int lprefix;
const char *name;
/* If we aren't generating fix-and-continue code, don't do anything special. */
if (TARGET_FIX_AND_CONTINUE == 0)
return 0;
/* Otherwise, all symbol except symbols that begin with L or _OBJC_
are indirected. Symbols that begin with L and _OBJC_ are always
bound to the current translation unit as they are used for
generated local data of the translation unit. */
name = XSTR (sym_ref, 0);
lprefix = (((name[0] == '*' || name[0] == '&')
&& (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
|| (strncmp (name, "_OBJC_", 6) == 0));
return ! lprefix;
}
// draw copyright message on the bottom on the screen
void player_select_display_copyright()
{
int sx, sy, w;
char Copyright_msg1[256], Copyright_msg2[256];
// strcpy_s(Copyright_msg1, XSTR("Descent: FreeSpace - The Great War, Copyright c 1998, Volition, Inc.", -1));
gr_set_color_fast(&Color_white);
// sprintf(Copyright_msg1, NOX("FreeSpace 2"));
get_version_string(Copyright_msg1, sizeof(Copyright_msg1));
sprintf(Copyright_msg2, XSTR("Copyright %c 1999, Volition, Inc. All rights reserved.", 385), Lcl_special_chars + 4);
gr_get_string_size(&w, NULL, Copyright_msg1);
sx = fl2i((gr_screen.max_w_unscaled / 2) - w/2.0f + 0.5f);
sy = (gr_screen.max_h_unscaled - 2) - 2*gr_get_font_height();
gr_string(sx, sy, Copyright_msg1, GR_RESIZE_MENU);
gr_get_string_size(&w, NULL, Copyright_msg2);
sx = fl2i((gr_screen.max_w_unscaled / 2) - w/2.0f + 0.5f);
sy = (gr_screen.max_h_unscaled - 2) - gr_get_font_height();
gr_string(sx, sy, Copyright_msg2, GR_RESIZE_MENU);
}
/**
* Constructor for CJumpNode class, with world position argument
*/
CJumpNode::CJumpNode(vec3d *position) : m_radius(0.0f), m_modelnum(-1), m_objnum(-1), m_flags(0)
{
Assert(position != NULL);
gr_init_alphacolor(&m_display_color, 0, 255, 0, 255);
// Set m_name
sprintf(m_name, XSTR( "Jump Node %d", 632), Jump_nodes.size());
// Set m_modelnum and m_radius
m_modelnum = model_load(NOX("subspacenode.pof"), 0, NULL, 0);
if (m_modelnum == -1)
Warning(LOCATION, "Could not load default model for %s", m_name);
else
m_radius = model_get_radius(m_modelnum);
m_pos.xyz.x = position->xyz.x;
m_pos.xyz.y = position->xyz.y;
m_pos.xyz.z = position->xyz.z;
// Create the object
m_objnum = obj_create(OBJ_JUMP_NODE, -1, -1, NULL, &m_pos, m_radius, OF_RENDERS);
}
// attempt to kick a player. return success or fail
void multi_kick_player(int player_index, int ban, int reason)
{
// only the standalone should be able to kick the host of the game
if(!(Game_mode & GM_STANDALONE_SERVER) && ((Net_players[player_index].flags & NETINFO_FLAG_GAME_HOST) || (Net_players[player_index].flags & NETINFO_FLAG_AM_MASTER))){
nprintf(("Network","Cannot kick the host or server of a game!\n"));
} else {
// if we're the master, then delete the guy
if(Net_player->flags & NETINFO_FLAG_AM_MASTER){
// if we're supposed to ban him, add his address to the banned list
if(ban){
multi_kick_add_ban(&Net_players[player_index].p_info.addr);
}
// mark him as having been kicked
Net_players[player_index].flags |= NETINFO_FLAG_KICKED;
// set his kick timestamp and send him a leave game packet
Net_players[player_index].s_info.kick_timestamp = timestamp(MULTI_KICK_RESPONSE_TIME);
Net_players[player_index].s_info.kick_reason = reason;
send_leave_game_packet(Net_players[player_index].player_id, reason, &Net_players[player_index]);
// tell everyone else that he was kicked
send_leave_game_packet(Net_players[player_index].player_id, reason);
// wait until he either shuts his connection down or he times out)
// add the string to the chatbox and the hud (always safe - if it is not inited, nothing bad will happen)
char str[512];
memset(str, 0, 512);
sprintf(str, XSTR("<kicking %s ...>", 1501), Net_players[player_index].m_player->callsign);
multi_display_chat_msg(str, player_index, 0);
}
// otherwise, we should send the packet indicating that this guy should be kicked
else {
send_player_kick_packet(player_index, ban, reason);
}
}
}
/*!
It's used in the LAME VBR tag only.
\param void
\return a pointer to the short version of the LAME version string.
*/
const char* get_lame_very_short_version ( void )
{
/* adding date and time to version string makes it harder for output
validation */
#if LAME_ALPHA_VERSION > 0
static /*@observer@*/ const char *const str =
"LAME" XSTR(LAME_MAJOR_VERSION) "." XSTR(LAME_MINOR_VERSION) "a";
#elif LAME_BETA_VERSION > 0
static /*@observer@*/ const char *const str =
"LAME" XSTR(LAME_MAJOR_VERSION) "." XSTR(LAME_MINOR_VERSION) "b";
#else
static /*@observer@*/ const char *const str =
"LAME" XSTR(LAME_MAJOR_VERSION) "." XSTR(LAME_MINOR_VERSION) " ";
#endif
return str;
}
static void
i386_pe_mark_dllexport (tree decl)
{
const char *oldname;
char *newname;
rtx rtlname;
rtx symref;
tree idp;
rtlname = XEXP (DECL_RTL (decl), 0);
if (GET_CODE (rtlname) == MEM)
rtlname = XEXP (rtlname, 0);
gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
oldname = XSTR (rtlname, 0);
if (i386_pe_dllimport_name_p (oldname))
{
warning (0, "inconsistent dll linkage for %q+D, dllexport assumed",
decl);
/* Remove DLL_IMPORT_PREFIX. */
oldname += strlen (DLL_IMPORT_PREFIX);
}
else if (i386_pe_dllexport_name_p (oldname))
return; /* already done */
newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);
sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);
/* We pass newname through get_identifier to ensure it has a unique
address. RTL processing can sometimes peek inside the symbol ref
and compare the string's addresses to see if two symbols are
identical. */
idp = get_identifier (newname);
symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
SET_SYMBOL_REF_DECL (symref, decl);
XEXP (DECL_RTL (decl), 0) = symref;
}
void carve::csg::Intersections::collect(const IObj &obj,
std::vector<carve::mesh::MeshSet<3>::vertex_t *> *collect_v,
std::vector<carve::mesh::MeshSet<3>::edge_t *> *collect_e,
std::vector<carve::mesh::MeshSet<3>::face_t *> *collect_f) const {
carve::csg::Intersections::const_iterator i = find(obj);
if (i != end()) {
Intersections::mapped_type::const_iterator a, b;
for (a = (*i).second.begin(), b = (*i).second.end(); a != b; ++a) {
switch ((*a).first.obtype) {
case carve::csg::IObj::OBTYPE_VERTEX:
if (collect_v) collect_v->push_back((*a).first.vertex);
break;
case carve::csg::IObj::OBTYPE_EDGE:
if (collect_e) collect_e->push_back((*a).first.edge);
break;
case carve::csg::IObj::OBTYPE_FACE:
if (collect_f) collect_f->push_back((*a).first.face);
break;
default:
throw carve::exception("should not happen " __FILE__ ":" XSTR(__LINE__));
}
}
}
}
rtx
gen_rtx_fmt_iuuB00is (RTX_CODE code, enum machine_mode mode,
int arg0,
rtx arg1,
rtx arg2,
struct basic_block_def *arg3,
int arg4,
const char *arg5)
{
rtx rt;
rt = rtx_alloc (code);
PUT_MODE (rt, mode);
XINT (rt, 0) = arg0;
XEXP (rt, 1) = arg1;
XEXP (rt, 2) = arg2;
XBBDEF (rt, 3) = arg3;
X0EXP (rt, 4) = NULL_RTX;
X0EXP (rt, 5) = NULL_RTX;
XINT (rt, 6) = arg4;
XSTR (rt, 7) = arg5;
return rt;
}
/*
****************************************************************
* Executa a opção "-p" (outros padrões) *
****************************************************************
*/
int
put_p_option (char *cp, const char *pat_vec[], int *pati_ptr)
{
char c;
for (EVER)
{
while ((c = *cp) == ' ' || c == '\t' )
cp++;
if (c == '\0')
return (0);
if (*pati_ptr >= NPAT)
{
printf
( "%s: No momento somente aceitamos "
XSTR (NPAT) " padrões\n\n",
pgname
);
help ();
}
pat_vec[(*pati_ptr)++] = cp++;
while ((c = *cp) != '\0' && c != ' ' && c != '\t')
cp++;
if (c == '\0')
return (0);
*cp++ = '\0';
} /* end for (EVER) */
} /* end put_p_option */
// draw squad image and clean up afterwards
void barracks_draw_squad_pic()
{
char buf[40];
// draw pilot pic
if (Cur_pilot->callsign[0] && (Pic_squad_number >= 0) && (Pic_squad_number < Num_pilot_squad_images)) {
if (Pilot_squad_images[Pic_squad_number] >= 0) {
// JAS: This code is hacked to allow the animation to use all 256 colors
extern int Palman_allow_any_color;
Palman_allow_any_color = 1;
gr_set_bitmap(Pilot_squad_images[Pic_squad_number]);
gr_bitmap(Barracks_squad_coords[gr_screen.res][BARRACKS_X_COORD], Barracks_squad_coords[gr_screen.res][BARRACKS_Y_COORD], GR_RESIZE_MENU);
Palman_allow_any_color = 0;
// print number of current squad pic
if(Player_sel_mode != PLAYER_SELECT_MODE_SINGLE){
sprintf(buf,XSTR( "%d of %d", 71), Pic_squad_number+1, Num_pilot_squad_images);
gr_printf_menu(Barracks_squad_number_coords[gr_screen.res][BARRACKS_X_COORD], Barracks_squad_number_coords[gr_screen.res][BARRACKS_Y_COORD], buf);
}
}
} else {
Pic_squad_number = -1;
}
}
/* Recursive hash function for RTL X. */
static hashval_t
rtx_hash (rtx x)
{
int i, j;
enum rtx_code code;
const char *fmt;
hashval_t val = 0;
if (x == 0)
return val;
code = GET_CODE (x);
val += (int) code + 4095;
/* Some RTL can be compared nonrecursively. */
switch (code)
{
case REG:
return val + REGNO (x);
case LABEL_REF:
return iterative_hash_object (XEXP (x, 0), val);
case SYMBOL_REF:
return iterative_hash_object (XSTR (x, 0), val);
case SCRATCH:
case CONST_DOUBLE:
case CONST_INT:
case CONST_VECTOR:
return val;
default:
break;
}
/* Hash the elements. */
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
switch (fmt[i])
{
case 'w':
val += XWINT (x, i);
break;
case 'n':
case 'i':
val += XINT (x, i);
break;
case 'V':
case 'E':
val += XVECLEN (x, i);
for (j = 0; j < XVECLEN (x, i); j++)
val += rtx_hash (XVECEXP (x, i, j));
break;
case 'e':
val += rtx_hash (XEXP (x, i));
break;
case 'S':
case 's':
val += htab_hash_string (XSTR (x, i));
break;
case 'u':
case '0':
case 't':
break;
/* It is believed that rtx's at this level will never
contain anything but integers and other rtx's, except for
within LABEL_REFs and SYMBOL_REFs. */
default:
abort ();
}
}
return val;
}
hashval_t
iterative_hash_rtx (const_rtx x, hashval_t hash)
{
enum rtx_code code;
enum machine_mode mode;
int i, j;
const char *fmt;
if (x == NULL_RTX)
return hash;
code = GET_CODE (x);
hash = iterative_hash_object (code, hash);
mode = GET_MODE (x);
hash = iterative_hash_object (mode, hash);
switch (code)
{
case REG:
i = REGNO (x);
return iterative_hash_object (i, hash);
case CONST_INT:
return iterative_hash_object (INTVAL (x), hash);
case SYMBOL_REF:
if (XSTR (x, 0))
return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
hash);
return hash;
case LABEL_REF:
case DEBUG_EXPR:
case VALUE:
case SCRATCH:
case CONST_DOUBLE:
case CONST_FIXED:
case DEBUG_IMPLICIT_PTR:
case DEBUG_PARAMETER_REF:
return hash;
default:
break;
}
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
switch (fmt[i])
{
case 'w':
hash = iterative_hash_object (XWINT (x, i), hash);
break;
case 'n':
case 'i':
hash = iterative_hash_object (XINT (x, i), hash);
break;
case 'V':
case 'E':
j = XVECLEN (x, i);
hash = iterative_hash_object (j, hash);
for (j = 0; j < XVECLEN (x, i); j++)
hash = iterative_hash_rtx (XVECEXP (x, i, j), hash);
break;
case 'e':
hash = iterative_hash_rtx (XEXP (x, i), hash);
break;
case 'S':
case 's':
if (XSTR (x, i))
hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
hash);
break;
default:
break;
}
return hash;
}
void radar_draw_range()
{
char buf[32];
// hud_set_bright_color();
hud_set_gauge_color(HUD_RADAR, HUD_C_BRIGHT);
switch ( HUD_config.rp_dist ) {
case RR_SHORT:
gr_printf(Radar_dist_coords[gr_screen.res][RR_SHORT][0], Radar_dist_coords[gr_screen.res][RR_SHORT][1], XSTR( "2k", 467));
break;
case RR_LONG:
gr_printf(Radar_dist_coords[gr_screen.res][RR_LONG][0], Radar_dist_coords[gr_screen.res][RR_LONG][1], XSTR( "10k", 468));
break;
case RR_INFINITY:
sprintf(buf, NOX("%c"), Lcl_special_chars);
gr_printf(Radar_dist_coords[gr_screen.res][RR_INFINITY][0], Radar_dist_coords[gr_screen.res][RR_INFINITY][1], buf);
break;
default:
Int3(); // can't happen (get Alan if it does)
break;
}
hud_set_default_color();
}
int
rtx_equal_p (const_rtx x, const_rtx y)
{
int i;
int j;
enum rtx_code code;
const char *fmt;
if (x == y)
return 1;
if (x == 0 || y == 0)
return 0;
code = GET_CODE (x);
/* Rtx's of different codes cannot be equal. */
if (code != GET_CODE (y))
return 0;
/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
(REG:SI x) and (REG:HI x) are NOT equivalent. */
if (GET_MODE (x) != GET_MODE (y))
return 0;
/* MEMs referring to different address space are not equivalent. */
if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
return 0;
/* Some RTL can be compared nonrecursively. */
switch (code)
{
case REG:
return (REGNO (x) == REGNO (y));
case LABEL_REF:
return XEXP (x, 0) == XEXP (y, 0);
case SYMBOL_REF:
return XSTR (x, 0) == XSTR (y, 0);
case DEBUG_EXPR:
case VALUE:
case SCRATCH:
case CONST_DOUBLE:
case CONST_INT:
case CONST_FIXED:
return 0;
case DEBUG_IMPLICIT_PTR:
return DEBUG_IMPLICIT_PTR_DECL (x)
== DEBUG_IMPLICIT_PTR_DECL (y);
case DEBUG_PARAMETER_REF:
return DEBUG_PARAMETER_REF_DECL (x)
== DEBUG_PARAMETER_REF_DECL (y);
case ENTRY_VALUE:
return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
default:
break;
}
/* Compare the elements. If any pair of corresponding elements
fail to match, return 0 for the whole thing. */
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
switch (fmt[i])
{
case 'w':
if (XWINT (x, i) != XWINT (y, i))
return 0;
break;
case 'n':
case 'i':
if (XINT (x, i) != XINT (y, i))
{
#ifndef GENERATOR_FILE
if (((code == ASM_OPERANDS && i == 6)
|| (code == ASM_INPUT && i == 1))
&& locator_eq (XINT (x, i), XINT (y, i)))
break;
#endif
return 0;
}
break;
case 'V':
case 'E':
/* Two vectors must have the same length. */
if (XVECLEN (x, i) != XVECLEN (y, i))
return 0;
/* And the corresponding elements must match. */
for (j = 0; j < XVECLEN (x, i); j++)
if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
return 0;
break;
case 'e':
if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
return 0;
break;
case 'S':
case 's':
if ((XSTR (x, i) || XSTR (y, i))
&& (! XSTR (x, i) || ! XSTR (y, i)
|| strcmp (XSTR (x, i), XSTR (y, i))))
return 0;
break;
case 'u':
/* These are just backpointers, so they don't matter. */
break;
case '0':
case 't':
break;
/* It is believed that rtx's at this level will never
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
gcc_unreachable ();
}
}
return 1;
}
/* upnpDiscover() :
* return a chained list of all devices found or NULL if
* no devices was found.
* It is up to the caller to free the chained list
* delay is in millisecond (poll) */
struct UPNPDev * upnpDiscover(int delay, const char * multicastif,
const char * minissdpdsock, int sameport)
{
struct UPNPDev * tmp;
struct UPNPDev * devlist = 0;
int opt = 1;
static const char MSearchMsgFmt[] =
"M-SEARCH * HTTP/1.1\r\n"
"HOST: " UPNP_MCAST_ADDR ":" XSTR(PORT) "\r\n"
"ST: %s\r\n"
"MAN: \"ssdp:discover\"\r\n"
"MX: 3\r\n"
"\r\n";
static const char * const deviceList[] = {
"urn:schemas-upnp-org:device:InternetGatewayDevice:1",
"urn:schemas-upnp-org:service:WANIPConnection:1",
"urn:schemas-upnp-org:service:WANPPPConnection:1",
"upnp:rootdevice",
0
};
int deviceIndex = 0;
char bufr[1536]; /* reception and emission buffer */
int sudp;
int n;
struct sockaddr_in sockudp_r, sockudp_w;
#ifndef WIN32
/* first try to get infos from minissdpd ! */
if(!minissdpdsock)
minissdpdsock = "/var/run/minissdpd.sock";
while(!devlist && deviceList[deviceIndex]) {
devlist = getDevicesFromMiniSSDPD(deviceList[deviceIndex],
minissdpdsock);
/* We return what we have found if it was not only a rootdevice */
if(devlist && !strstr(deviceList[deviceIndex], "rootdevice"))
return devlist;
deviceIndex++;
}
deviceIndex = 0;
#endif
/* fallback to direct discovery */
#ifdef WIN32
sudp = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
#else
sudp = socket(PF_INET, SOCK_DGRAM, 0);
#endif
if(sudp < 0)
{
PRINT_SOCKET_ERROR("socket");
return NULL;
}
/* reception */
memset(&sockudp_r, 0, sizeof(struct sockaddr_in));
sockudp_r.sin_family = AF_INET;
if(sameport)
sockudp_r.sin_port = htons(PORT);
sockudp_r.sin_addr.s_addr = INADDR_ANY;
/* emission */
memset(&sockudp_w, 0, sizeof(struct sockaddr_in));
sockudp_w.sin_family = AF_INET;
sockudp_w.sin_port = htons(PORT);
sockudp_w.sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
#ifdef WIN32
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
#else
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
#endif
{
PRINT_SOCKET_ERROR("setsockopt");
return NULL;
}
if(multicastif)
{
struct in_addr mc_if;
mc_if.s_addr = inet_addr(multicastif);
sockudp_r.sin_addr.s_addr = mc_if.s_addr;
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
{
PRINT_SOCKET_ERROR("setsockopt");
}
}
/* Avant d'envoyer le paquet on bind pour recevoir la reponse */
if (bind(sudp, (struct sockaddr *)&sockudp_r, sizeof(struct sockaddr_in)) != 0)
{
PRINT_SOCKET_ERROR("bind");
closesocket(sudp);
return NULL;
}
/* receiving SSDP response packet */
for(n = 0;;)
{
if(n == 0)
{
/* sending the SSDP M-SEARCH packet */
n = snprintf(bufr, sizeof(bufr),
MSearchMsgFmt, deviceList[deviceIndex++]);
/*printf("Sending %s", bufr);*/
n = sendto(sudp, bufr, n, 0,
(struct sockaddr *)&sockudp_w, sizeof(struct sockaddr_in));
if (n < 0) {
PRINT_SOCKET_ERROR("sendto");
closesocket(sudp);
return devlist;
}
}
/* Waiting for SSDP REPLY packet to M-SEARCH */
n = ReceiveData(sudp, bufr, sizeof(bufr), delay);
if (n < 0) {
/* error */
closesocket(sudp);
return devlist;
} else if (n == 0) {
/* no data or Time Out */
if (devlist || (deviceList[deviceIndex] == 0)) {
/* no more device type to look for... */
closesocket(sudp);
return devlist;
}
} else {
const char * descURL=NULL;
int urlsize=0;
const char * st=NULL;
int stsize=0;
/*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
if(st&&descURL)
{
/*printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
stsize, st, urlsize, descURL); */
tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
tmp->pNext = devlist;
tmp->descURL = tmp->buffer;
tmp->st = tmp->buffer + 1 + urlsize;
memcpy(tmp->buffer, descURL, urlsize);
tmp->buffer[urlsize] = '\0';
memcpy(tmp->buffer + urlsize + 1, st, stsize);
tmp->buffer[urlsize+1+stsize] = '\0';
devlist = tmp;
}
}
}
}
/**
* Main. Creates Application window.
*
* Cleaning up #defines.
*/
int main(int argc, char** argv) {
RS_DEBUG->setLevel(RS_Debug::D_WARNING);
RS_DEBUG->print("param 0: %s", argv[0]);
QCoreApplication::setApplicationName(XSTR(QC_APPNAME));
#if QT_VERSION < 0x040400
/* No such property in Qt 4.3 */
#else
QCoreApplication::setApplicationVersion(XSTR(QC_VERSION));
#endif
QApplication app(argc, argv);
// for image mime resources from png files
// TODO: kinda dirty to call that explicitly
// QINITIMAGES_LIBRECAD();
#ifdef RS_SCRIPTING
// qInitImages_librecad();
#endif
for (int i=0; i<app.argc(); i++) {
if (QString("--debug") == app.argv()[i]) {
RS_DEBUG->setLevel(RS_Debug::D_DEBUGGING);
}
}
QFileInfo prgInfo( QFile::decodeName(argv[0]) );
QString prgDir(prgInfo.absolutePath());
RS_SETTINGS->init(XSTR(QC_COMPANYKEY), XSTR(QC_APPKEY));
RS_SYSTEM->init(XSTR(QC_APPNAME), XSTR(QC_VERSION), XSTR(QC_APPDIR), prgDir);
RS_FileIO::instance()->registerFilter(&( RS_FilterLFF::createFilter));
RS_FileIO::instance()->registerFilter( &(RS_FilterDXFRW::createFilter));
RS_FileIO::instance()->registerFilter( &(RS_FilterCXF::createFilter));
RS_FileIO::instance()->registerFilter( &(RS_FilterJWW::createFilter));
RS_FileIO::instance()->registerFilter( &(RS_FilterDXF1::createFilter));
// parse command line arguments that might not need a launched program:
QStringList fileList = handleArgs(argc, argv);
QString lang;
QString langCmd;
QString unit;
RS_SETTINGS->beginGroup("/Defaults");
#ifndef QC_PREDEFINED_UNIT
unit = RS_SETTINGS->readEntry("/Unit", "Invalid");
#else
unit = RS_SETTINGS->readEntry("/Unit", QC_PREDEFINED_UNIT);
#endif
RS_SETTINGS->endGroup();
// show initial config dialog:
if (unit=="Invalid") {
RS_DEBUG->print("main: show initial config dialog..");
QG_DlgInitial di(NULL);
di.setText("<font size=\"+1\"><b>Welcome to " XSTR(QC_APPNAME) "</b></font>"
"<br>"
"Please choose the unit you want to use for new drawings and your "
"preferred language.<br>"
"You can changes these settings later in the "
"Options Dialog of " XSTR(QC_APPNAME) ".");
QPixmap pxm(":/main/intro_librecad.png");
di.setPixmap(pxm);
if (di.exec()) {
RS_SETTINGS->beginGroup("/Defaults");
unit = RS_SETTINGS->readEntry("/Unit", "None");
RS_SETTINGS->endGroup();
}
RS_DEBUG->print("main: show initial config dialog: OK");
}
#ifdef QSPLASHSCREEN_H
RS_DEBUG->print("main: splashscreen..");
QPixmap* pixmap = new QPixmap(":/main/splash_librecad.png");
# endif
RS_DEBUG->print("main: init fontlist..");
RS_FONTLIST->init();
RS_DEBUG->print("main: init fontlist: OK");
RS_DEBUG->print("main: init patternlist..");
RS_PATTERNLIST->init();
RS_DEBUG->print("main: init patternlist: OK");
RS_DEBUG->print("main: init scriptlist..");
RS_SCRIPTLIST->init();
RS_DEBUG->print("main: init scriptlist: OK");
RS_DEBUG->print("main: loading translation..");
RS_SETTINGS->beginGroup("/Appearance");
#ifdef QC_PREDEFINED_LOCALE
lang = RS_SETTINGS->readEntry("/Language", "");
if (lang.isEmpty()) {
lang=QC_PREDEFINED_LOCALE;
RS_SETTINGS->writeEntry("/Language", lang);
}
langCmd = RS_SETTINGS->readEntry("/LanguageCmd", "");
if (langCmd.isEmpty()) {
langCmd=QC_PREDEFINED_LOCALE;
RS_SETTINGS->writeEntry("/LanguageCmd", langCmd);
}
#else
lang = RS_SETTINGS->readEntry("/Language", "en");
langCmd = RS_SETTINGS->readEntry("/LanguageCmd", "en");
#endif
RS_SETTINGS->endGroup();
RS_SYSTEM->loadTranslation(lang, langCmd);
RS_DEBUG->print("main: loading translation: OK");
#ifdef QSPLASHSCREEN_H
splash = new QSplashScreen(*pixmap);
splash->show();
splash->showMessage(QObject::tr("Loading.."),
Qt::AlignRight|Qt::AlignBottom, QC_SPLASH_TXTCOL);
RS_DEBUG->print("main: splashscreen: OK");
#endif
//QApplication::setStyle(new QWindowsStyle());
//QApplication::setStyle(new QPlatinumStyle());
#ifdef QC_BUILTIN_STYLE //js:
RS_DEBUG->print("main: applying built in style..");
applyBuiltinStyle();
#endif
RS_DEBUG->print("main: creating main window..");
QC_ApplicationWindow * appWin = new QC_ApplicationWindow();
RS_DEBUG->print("main: setting caption");
appWin->setWindowTitle(XSTR(QC_APPNAME));
RS_DEBUG->print("main: show main window");
appWin->show();
RS_DEBUG->print("main: set focus");
appWin->setFocus();
RS_DEBUG->print("main: creating main window: OK");
#ifdef QSPLASHSCREEN_H
if (splash) {
RS_DEBUG->print("main: updating splash..");
splash->showMessage(QObject::tr("Loading..."),
Qt::AlignRight|Qt::AlignBottom, QC_SPLASH_TXTCOL);
RS_DEBUG->print("main: processing events");
qApp->processEvents();
RS_DEBUG->print("main: updating splash: OK");
}
#endif
// Set LC_NUMERIC so that enetring numeric values uses . as teh decimal seperator
setlocale(LC_NUMERIC, "C");
RS_DEBUG->print("main: loading files..");
bool files_loaded = false;
for (QStringList::Iterator it = fileList.begin(); it != fileList.end();
++it ) {
#ifdef QSPLASHSCREEN_H
if (splash) {
splash->showMessage(QObject::tr("Loading File %1..")
.arg(QDir::toNativeSeparators(*it)),
Qt::AlignRight|Qt::AlignBottom, QC_SPLASH_TXTCOL);
qApp->processEvents();
}
#endif
appWin->slotFileOpen(*it, RS2::FormatUnknown);
files_loaded = true;
}
RS_DEBUG->print("main: loading files: OK");
#ifdef QSPLASHSCREEN_H
# ifndef QC_DELAYED_SPLASH_SCREEN
if (splash) {
splash->finish(appWin);
delete splash;
splash = 0;
}
# endif
delete pixmap;
#endif
//app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
RS_DEBUG->print("main: app.exec()");
if (!files_loaded) {
appWin->slotFileNewNew();
}
appWin->slotRunStartScript();
int r = app.exec();
RS_DEBUG->print("main: Temporary disabled delete appWin");
// delete appWin;
RS_DEBUG->print("main: finished");
return r;
}
int main(int argc, char *argv[])
{
struct RNAcofold_args_info args_info;
unsigned int input_type;
char *string, *input_string;
char *structure, *cstruc, *rec_sequence, *orig_sequence, *rec_id, **rec_rest;
char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH];
char *ParamFile;
char *ns_bases, *c;
char *Concfile;
int i, length, l, sym, r, cl;
double min_en;
double kT, sfact, betaScale;
int pf, istty;
int noconv, noPS;
int doT; /*compute dimere free energies etc.*/
int doC; /*toggle to compute concentrations*/
int doQ; /*toggle to compute prob of base being paired*/
int cofi; /*toggle concentrations stdin / file*/
plist *prAB;
plist *prAA; /*pair probabilities of AA dimer*/
plist *prBB;
plist *prA;
plist *prB;
plist *mfAB;
plist *mfAA; /*pair mfobabilities of AA dimer*/
plist *mfBB;
plist *mfA;
plist *mfB;
double *ConcAandB;
unsigned int rec_type, read_opt;
pf_paramT *pf_parameters;
model_detailsT md;
/*
#############################################
# init variables and parameter options
#############################################
*/
dangles = 2;
sfact = 1.07;
bppmThreshold = 1e-5;
noconv = 0;
noPS = 0;
do_backtrack = 1;
pf = 0;
doT = 0;
doC = 0;
doQ = 0;
cofi = 0;
betaScale = 1.;
gquad = 0;
ParamFile = NULL;
pf_parameters = NULL;
string = NULL;
Concfile = NULL;
structure = NULL;
cstruc = NULL;
ns_bases = NULL;
rec_type = read_opt = 0;
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
set_model_details(&md);
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNAcofold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.constraint_given) fold_constrained=1;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) md.special_hp = tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg < 0) || (args_info.dangles_arg > 3))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
md.dangles = dangles = args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) md.noLP = noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) md.noGU = noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) md.noGUclosure = no_closingGU = 1;
/* gquadruplex support */
if(args_info.gquad_given) md.gquad = gquad = 1;
/* enforce canonical base pairs in any case? */
if(args_info.canonicalBPonly_given) md.canonicalBPonly = canonicalBPonly = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* */
if(args_info.noPS_given) noPS = 1;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set pf scaling factor */
if(args_info.pfScale_given) sfact = args_info.pfScale_arg;
if(args_info.all_pf_given) doT = pf = 1;
/* concentrations from stdin */
if(args_info.concentrations_given) doC = doT = pf = 1;
/* set the bppm threshold for the dotplot */
if(args_info.bppmThreshold_given)
bppmThreshold = MIN2(1., MAX2(0.,args_info.bppmThreshold_arg));
/* concentrations in file */
if(args_info.betaScale_given) betaScale = args_info.betaScale_arg;
if(args_info.concfile_given){
Concfile = strdup(args_info.concfile_arg);
doC = cofi = doT = pf = 1;
}
/* partition function settings */
if(args_info.partfunc_given){
pf = 1;
if(args_info.partfunc_arg != -1)
do_backtrack = args_info.partfunc_arg;
}
/* free allocated memory of command line data structure */
RNAcofold_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if(pf && gquad){
nrerror("G-Quadruplex support is currently not available for partition function computations");
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/* print user help if we get input from tty */
if(istty){
printf("Use '&' to connect 2 sequences that shall form a complex.\n");
if(fold_constrained){
print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK);
print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n");
}
else print_tty_input_seq();
}
/* set options we wanna pass to read_record */
if(istty) read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
if(!fold_constrained) read_opt |= VRNA_INPUT_NO_REST;
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = read_record(&rec_id, &rec_sequence, &rec_rest, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
/*
########################################################
# init everything according to the data we've read
########################################################
*/
if(rec_id){
if(!istty) printf("%s\n", rec_id);
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
cut_point = -1;
rec_sequence = tokenize(rec_sequence); /* frees input_string and sets cut_point */
length = (int) strlen(rec_sequence);
structure = (char *) space((unsigned) length+1);
/* parse the rest of the current dataset to obtain a structure constraint */
if(fold_constrained){
cstruc = NULL;
int cp = cut_point;
unsigned int coptions = (rec_id) ? VRNA_CONSTRAINT_MULTILINE : 0;
coptions |= VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK;
getConstraint(&cstruc, (const char **)rec_rest, coptions);
cstruc = tokenize(cstruc);
if(cut_point != cp) nrerror("cut point in sequence and structure constraint differs");
cl = (cstruc) ? (int)strlen(cstruc) : 0;
if(cl == 0) warn_user("structure constraint is missing");
else if(cl < length) warn_user("structure constraint is shorter than sequence");
else if(cl > length) nrerror("structure constraint is too long");
if(cstruc) strncpy(structure, cstruc, sizeof(char)*(cl+1));
}
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(rec_sequence);
/* store case-unmodified sequence */
orig_sequence = strdup(rec_sequence);
/* convert sequence to uppercase letters only */
str_uppercase(rec_sequence);
if(istty){
if (cut_point == -1)
printf("length = %d\n", length);
else
printf("length1 = %d\nlength2 = %d\n", cut_point-1, length-cut_point+1);
}
/*
########################################################
# begin actual computations
########################################################
*/
if (doC) {
FILE *fp;
if (cofi) { /* read from file */
fp = fopen(Concfile, "r");
if (fp==NULL) {
fprintf(stderr, "could not open concentration file %s", Concfile);
nrerror("\n");
}
ConcAandB = read_concentrations(fp);
fclose(fp);
} else {
printf("Please enter concentrations [mol/l]\n format: ConcA ConcB\n return to end\n");
ConcAandB = read_concentrations(stdin);
}
}
/*compute mfe of AB dimer*/
min_en = cofold(rec_sequence, structure);
assign_plist_from_db(&mfAB, structure, 0.95);
{
char *pstring, *pstruct;
if (cut_point == -1) {
pstring = strdup(orig_sequence);
pstruct = strdup(structure);
} else {
pstring = costring(orig_sequence);
pstruct = costring(structure);
}
printf("%s\n%s", pstring, pstruct);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
printf(" (%6.2f)\n", min_en);
(void) fflush(stdout);
if (!noPS) {
char annot[512] = "";
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_ss.ps");
} else {
strcpy(ffname, "rna.ps");
}
if (cut_point >= 0)
sprintf(annot,
"1 %d 9 0 0.9 0.2 omark\n%d %d 9 1 0.1 0.2 omark\n",
cut_point-1, cut_point+1, length+1);
if(gquad){
if (!noPS) (void) PS_rna_plot_a_gquad(pstring, pstruct, ffname, annot, NULL);
} else {
if (!noPS) (void) PS_rna_plot_a(pstring, pstruct, ffname, annot, NULL);
}
}
free(pstring);
free(pstruct);
}
if (length>2000) free_co_arrays();
/*compute partition function*/
if (pf) {
cofoldF AB, AA, BB;
FLT_OR_DBL *probs;
if (dangles==1) {
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = energy_of_structure(rec_sequence, structure, 0);
dangles=1;
}
kT = (betaScale*((temperature+K0)*GASCONST))/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
pf_parameters = get_boltzmann_factors(temperature, betaScale, md, pf_scale);
if (cstruc!=NULL)
strncpy(structure, cstruc, length+1);
AB = co_pf_fold_par(rec_sequence, structure, pf_parameters, do_backtrack, fold_constrained);
if (do_backtrack) {
char *costruc;
costruc = (char *) space(sizeof(char)*(strlen(structure)+2));
if (cut_point<0) printf("%s", structure);
else {
strncpy(costruc, structure, cut_point-1);
strcat(costruc, "&");
strcat(costruc, structure+cut_point-1);
printf("%s", costruc);
}
if (!istty) printf(" [%6.2f]\n", AB.FAB);
else printf("\n");/*8.6.04*/
}
if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", AB.FAB);
printf(" frequency of mfe structure in ensemble %g",
exp((AB.FAB-min_en)/kT));
printf(" , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB);
probs = export_co_bppm();
assign_plist_from_pr(&prAB, probs, length, bppmThreshold);
/* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/
/* free_co_arrays(); */
if (doT) { /* cofold of all dimers, monomers */
int Blength, Alength;
char *Astring, *Bstring, *orig_Astring, *orig_Bstring;
char *Newstring;
char Newname[30];
char comment[80];
if (cut_point<0) {
printf("Sorry, i cannot do that with only one molecule, please give me two or leave it\n");
free(mfAB);
free(prAB);
continue;
}
if (dangles==1) dangles=2;
Alength=cut_point-1; /*length of first molecule*/
Blength=length-cut_point+1; /*length of 2nd molecule*/
Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/
Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/
strncat(Astring,rec_sequence,Alength);
strncat(Bstring,rec_sequence+Alength,Blength);
orig_Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/
orig_Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/
strncat(orig_Astring,orig_sequence,Alength);
strncat(orig_Bstring,orig_sequence+Alength,Blength);
/* compute AA dimer */
AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA, pf_parameters);
/* compute BB dimer */
BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB, pf_parameters);
/*free_co_pf_arrays();*/
/* compute A monomer */
do_partfunc(Astring, Alength, 1, &prA, &mfA, pf_parameters);
/* compute B monomer */
do_partfunc(Bstring, Blength, 1, &prB, &mfB, pf_parameters);
compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB, Alength);
compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA, Alength);
compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB, Blength);
printf("Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f\t%6f\t%6f\t%6f\t%6f\n",
AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB);
if (doC) {
do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB, ConcAandB);
free(ConcAandB);/*freeen*/
}
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp5.ps");
} else strcpy(ffname, "dot5.ps");
/*output of the 5 dot plots*/
/*AB dot_plot*/
/*write Free Energy into comment*/
sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB);
/*reset cut_point*/
cut_point=Alength+1;
/*write New name*/
strcpy(Newname,"AB");
strcat(Newname,ffname);
(void)PS_dot_plot_list(orig_sequence, Newname, prAB, mfAB, comment);
/*AA dot_plot*/
sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB);
/*write New name*/
strcpy(Newname,"AA");
strcat(Newname,ffname);
/*write AA sequence*/
Newstring=(char*)space((2*Alength+1)*sizeof(char));
strcpy(Newstring,orig_Astring);
strcat(Newstring,orig_Astring);
(void)PS_dot_plot_list(Newstring, Newname, prAA, mfAA, comment);
free(Newstring);
/*BB dot_plot*/
sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB);
/*write New name*/
strcpy(Newname,"BB");
strcat(Newname,ffname);
/*write BB sequence*/
Newstring=(char*)space((2*Blength+1)*sizeof(char));
strcpy(Newstring,orig_Bstring);
strcat(Newstring,orig_Bstring);
/*reset cut_point*/
cut_point=Blength+1;
(void)PS_dot_plot_list(Newstring, Newname, prBB, mfBB, comment);
free(Newstring);
/*A dot plot*/
/*reset cut_point*/
cut_point=-1;
sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA);
/*write New name*/
strcpy(Newname,"A");
strcat(Newname,ffname);
/*write BB sequence*/
(void)PS_dot_plot_list(orig_Astring, Newname, prA, mfA, comment);
/*B monomer dot plot*/
sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB);
/*write New name*/
strcpy(Newname,"B");
strcat(Newname,ffname);
/*write BB sequence*/
(void)PS_dot_plot_list(orig_Bstring, Newname, prB, mfB, comment);
free(Astring); free(Bstring); free(orig_Astring); free(orig_Bstring);
free(prAB); free(prAA); free(prBB); free(prA); free(prB);
free(mfAB); free(mfAA); free(mfBB); free(mfA); free(mfB);
} /*end if(doT)*/
free(pf_parameters);
}/*end if(pf)*/
if (do_backtrack) {
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
} else strcpy(ffname, "dot.ps");
if (!doT) {
if (pf) { (void) PS_dot_plot_list(rec_sequence, ffname, prAB, mfAB, "doof");
free(prAB);}
free(mfAB);
}
}
if (!doT) free_co_pf_arrays();
(void) fflush(stdout);
/* clean up */
if(cstruc) free(cstruc);
if(rec_id) free(rec_id);
free(rec_sequence);
free(orig_sequence);
free(structure);
/* free the rest of current dataset */
if(rec_rest){
for(i=0;rec_rest[i];i++) free(rec_rest[i]);
free(rec_rest);
}
rec_id = rec_sequence = orig_sequence = structure = cstruc = NULL;
rec_rest = NULL;
/* print user help for the next round if we get input from tty */
if(istty){
printf("Use '&' to connect 2 sequences that shall form a complex.\n");
if(fold_constrained){
print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK);
print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n");
}
else print_tty_input_seq();
}
}
return EXIT_SUCCESS;
}
/* upnpDiscover() :
* return a chained list of all devices found or NULL if
* no devices was found.
* It is up to the caller to free the chained list
* delay is in millisecond (poll) */
LIBSPEC struct UPNPDev *
upnpDiscover(int delay, const char * multicastif,
const char * minissdpdsock, int sameport,
int ipv6,
int * error)
{
struct UPNPDev * tmp;
struct UPNPDev * devlist = 0;
unsigned int scope_id = 0;
int opt = 1;
static const char MSearchMsgFmt[] =
"M-SEARCH * HTTP/1.1\r\n"
"HOST: %s:" XSTR(PORT) "\r\n"
"ST: %s\r\n"
"MAN: \"ssdp:discover\"\r\n"
"MX: %u\r\n"
"\r\n";
static const char * const deviceList[] = {
#if 0
"urn:schemas-upnp-org:device:InternetGatewayDevice:2",
"urn:schemas-upnp-org:service:WANIPConnection:2",
#endif
"urn:schemas-upnp-org:device:InternetGatewayDevice:1",
"urn:schemas-upnp-org:service:WANIPConnection:1",
"urn:schemas-upnp-org:service:WANPPPConnection:1",
"upnp:rootdevice",
0
};
int deviceIndex = 0;
char bufr[1536]; /* reception and emission buffer */
int sudp;
int n;
struct sockaddr_storage sockudp_r;
unsigned int mx;
#ifdef NO_GETADDRINFO
struct sockaddr_storage sockudp_w;
#else
int rv;
struct addrinfo hints, *servinfo, *p;
#endif
#ifdef _WIN32
MIB_IPFORWARDROW ip_forward;
#endif
int linklocal = 1;
if(error)
*error = UPNPDISCOVER_UNKNOWN_ERROR;
/* fallback to direct discovery */
#ifdef _WIN32
sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
#else
sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
#endif
if(sudp < 0)
{
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
PRINT_SOCKET_ERROR("socket");
return NULL;
}
/* reception */
memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
if(ipv6) {
struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
p->sin6_family = AF_INET6;
if(sameport)
p->sin6_port = htons(PORT);
p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
} else {
struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
p->sin_family = AF_INET;
if(sameport)
p->sin_port = htons(PORT);
p->sin_addr.s_addr = INADDR_ANY;
}
#ifdef _WIN32
/* This code could help us to use the right Network interface for
* SSDP multicast traffic */
/* Get IP associated with the index given in the ip_forward struct
* in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
if(!ipv6
&& (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {
DWORD dwRetVal = 0;
PMIB_IPADDRTABLE pIPAddrTable;
DWORD dwSize = 0;
#ifdef DEBUG
IN_ADDR IPAddr;
#endif
int i;
#ifdef DEBUG
printf("ifIndex=%lu nextHop=%lx \n", ip_forward.dwForwardIfIndex, ip_forward.dwForwardNextHop);
#endif
pIPAddrTable = (MIB_IPADDRTABLE *) malloc(sizeof (MIB_IPADDRTABLE));
if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
free(pIPAddrTable);
pIPAddrTable = (MIB_IPADDRTABLE *) malloc(dwSize);
}
if(pIPAddrTable) {
dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );
#ifdef DEBUG
printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
#endif
for (i=0; i < (int) pIPAddrTable->dwNumEntries; i++) {
#ifdef DEBUG
printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex);
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
printf("\tIP Address[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
printf("\tSubnet Mask[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
printf("\tBroadCast[%d]: \t%s (%ld)\n", i, inet_ntoa(IPAddr), pIPAddrTable->table[i].dwBCastAddr);
printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize);
printf("\tType and State[%d]:", i);
printf("\n");
#endif
if (pIPAddrTable->table[i].dwIndex == ip_forward.dwForwardIfIndex) {
/* Set the address of this interface to be used */
struct in_addr mc_if;
memset(&mc_if, 0, sizeof(mc_if));
mc_if.s_addr = pIPAddrTable->table[i].dwAddr;
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
PRINT_SOCKET_ERROR("setsockopt");
}
((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = pIPAddrTable->table[i].dwAddr;
#ifndef DEBUG
break;
#endif
}
}
free(pIPAddrTable);
pIPAddrTable = NULL;
}
}
#endif
#ifdef _WIN32
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
#else
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
#endif
{
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
PRINT_SOCKET_ERROR("setsockopt");
return NULL;
}
if(multicastif)
{
if(ipv6) {
#if !defined(_WIN32)
/* according to MSDN, if_nametoindex() is supported since
* MS Windows Vista and MS Windows Server 2008.
* http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(&ifindex)) < 0)
{
PRINT_SOCKET_ERROR("setsockopt");
}
#else
#ifdef DEBUG
printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
#endif
#endif
} else {
struct in_addr mc_if;
mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */
if(mc_if.s_addr != INADDR_NONE)
{
((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
{
PRINT_SOCKET_ERROR("setsockopt");
}
} else {
#ifdef HAS_IP_MREQN
/* was not an ip address, try with an interface name */
struct ip_mreqn reqn; /* only defined with -D_BSD_SOURCE or -D_GNU_SOURCE */
memset(&reqn, 0, sizeof(struct ip_mreqn));
reqn.imr_ifindex = if_nametoindex(multicastif);
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&reqn, sizeof(reqn)) < 0)
{
PRINT_SOCKET_ERROR("setsockopt");
}
#else
#ifdef DEBUG
printf("Setting of multicast interface not supported with interface name.\n");
#endif
#endif
}
}
}
/* Avant d'envoyer le paquet on bind pour recevoir la reponse */
if (bind(sudp, (const struct sockaddr *)&sockudp_r,
ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
{
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
PRINT_SOCKET_ERROR("bind");
closesocket(sudp);
return NULL;
}
if(error)
*error = UPNPDISCOVER_SUCCESS;
/* Calculating maximum response time in seconds */
mx = ((unsigned int)delay) / 1000u;
/* receiving SSDP response packet */
for(n = 0; deviceList[deviceIndex]; deviceIndex++)
{
if(n == 0)
{
/* sending the SSDP M-SEARCH packet */
n = snprintf(bufr, sizeof(bufr),
MSearchMsgFmt,
ipv6 ?
(linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")
: UPNP_MCAST_ADDR,
deviceList[deviceIndex], mx);
#ifdef DEBUG
printf("Sending %s", bufr);
#endif
#ifdef NO_GETADDRINFO
/* the following code is not using getaddrinfo */
/* emission */
memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
if(ipv6) {
struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
p->sin6_family = AF_INET6;
p->sin6_port = htons(PORT);
inet_pton(AF_INET6,
linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
&(p->sin6_addr));
} else {
struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
p->sin_family = AF_INET;
p->sin_port = htons(PORT);
p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
}
n = sendto(sudp, bufr, n, 0,
&sockudp_w,
ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
if (n < 0) {
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
PRINT_SOCKET_ERROR("sendto");
break;
}
#else /* #ifdef NO_GETADDRINFO */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; /* AF_INET6 or AF_INET */
hints.ai_socktype = SOCK_DGRAM;
/*hints.ai_flags = */
if ((rv = getaddrinfo(ipv6
? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
: UPNP_MCAST_ADDR,
XSTR(PORT), &hints, &servinfo)) != 0) {
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
#ifdef _WIN32
fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
#else
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
#endif
break;
}
for(p = servinfo; p; p = p->ai_next) {
n = sendto(sudp, bufr, n, 0, p->ai_addr, p->ai_addrlen);
if (n < 0) {
#ifdef DEBUG
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
if (getnameinfo(p->ai_addr, p->ai_addrlen, hbuf, sizeof(hbuf), sbuf,
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
fprintf(stderr, "host:%s port:%s\n", hbuf, sbuf);
}
#endif
PRINT_SOCKET_ERROR("sendto");
continue;
}
}
freeaddrinfo(servinfo);
if(n < 0) {
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
break;
}
#endif /* #ifdef NO_GETADDRINFO */
}
/* Waiting for SSDP REPLY packet to M-SEARCH */
n = receivedata(sudp, bufr, sizeof(bufr), delay, &scope_id);
if (n < 0) {
/* error */
if(error)
*error = UPNPDISCOVER_SOCKET_ERROR;
break;
} else if (n == 0) {
/* no data or Time Out */
if (devlist) {
/* no more device type to look for... */
if(error)
*error = UPNPDISCOVER_SUCCESS;
break;
}
if(ipv6) {
if(linklocal) {
linklocal = 0;
--deviceIndex;
} else {
linklocal = 1;
}
}
} else {
const char * descURL=NULL;
int urlsize=0;
const char * st=NULL;
int stsize=0;
/*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
if(st&&descURL)
{
#ifdef DEBUG
printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
stsize, st, urlsize, descURL);
#endif
for(tmp=devlist; tmp; tmp = tmp->pNext) {
if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&
tmp->descURL[urlsize] == '\0' &&
memcmp(tmp->st, st, stsize) == 0 &&
tmp->st[stsize] == '\0')
break;
}
/* at the exit of the loop above, tmp is null if
* no duplicate device was found */
if(tmp)
continue;
tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
if(!tmp) {
/* memory allocation error */
if(error)
*error = UPNPDISCOVER_MEMORY_ERROR;
break;
}
tmp->pNext = devlist;
tmp->descURL = tmp->buffer;
tmp->st = tmp->buffer + 1 + urlsize;
memcpy(tmp->buffer, descURL, urlsize);
tmp->buffer[urlsize] = '\0';
memcpy(tmp->buffer + urlsize + 1, st, stsize);
tmp->buffer[urlsize+1+stsize] = '\0';
tmp->scope_id = scope_id;
devlist = tmp;
}
}
}
closesocket(sudp);
return devlist;
}
uint8_t Com::selectedLanguage; #endif #ifndef MACHINE_TYPE #if DRIVE_SYSTEM == DELTA #define MACHINE_TYPE "Delta" #elif DRIVE_SYSTEM == CARTESIAN #define MACHINE_TYPE "Mendel" #else #define MACHINE_TYPE "Core_XY" #endif #endif #ifndef FIRMWARE_URL #define FIRMWARE_URL "https://github.com/repetier/Repetier-Firmware/" #endif // FIRMWARE_URL FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:" FIRMWARE_URL " PROTOCOL_VERSION:1.0 MACHINE_TYPE:" MACHINE_TYPE " EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:3") FSTRINGVALUE(Com::tDebug,"Debug:") FSTRINGVALUE(Com::tOk,"ok") FSTRINGVALUE(Com::tNewline,"\r\n") FSTRINGVALUE(Com::tNAN,"NAN") FSTRINGVALUE(Com::tINF,"INF") FSTRINGVALUE(Com::tError,"Error:") FSTRINGVALUE(Com::tInfo,"Info:") FSTRINGVALUE(Com::tWarning,"Warning:") FSTRINGVALUE(Com::tResend,"Resend:") FSTRINGVALUE(Com::tEcho,"Echo:") FSTRINGVALUE(Com::tOkSpace,"ok ") FSTRINGVALUE(Com::tWrongChecksum,"Wrong checksum") FSTRINGVALUE(Com::tMissingChecksum,"Missing checksum") FSTRINGVALUE(Com::tFormatError,"Format error") FSTRINGVALUE(Com::tDonePrinting,"Done printing file")
void barracks_init_stats(scoring_struct *stats)
{
int Max_stat_lines = Ship_info.size() + 23;
int i;
float f;
int score_from_kills = 0;
//Set up variables
if(Stat_labels != NULL)
{
delete[] Stat_labels;
}
if(Stats != NULL)
{
delete[] Stats;
}
Stat_labels = (char (*)[STAT_COLUMN1_W]) new char[Max_stat_lines * STAT_COLUMN1_W];
Stats = (char (*)[STAT_COLUMN2_W]) new char[Max_stat_lines * STAT_COLUMN2_W];
//Now start throwing stuff in
Num_stat_lines = 0;
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "*All Time Stats", 50));
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Primary weapon shots:", 51));
sprintf(Stats[Num_stat_lines], "%u", stats->p_shots_fired);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Primary weapon hits:", 52));
sprintf(Stats[Num_stat_lines], "%u", stats->p_shots_hit);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Primary friendly hits:", 53));
sprintf(Stats[Num_stat_lines], "%u", stats->p_bonehead_hits);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Primary hit %:", 54));
if (stats->p_shots_fired > 0) {
f = (float) stats->p_shots_hit * 100.0f / (float) stats->p_shots_fired;
} else {
f = 0.0f;
}
sprintf(Stats[Num_stat_lines], XSTR( "%.1f%%", 55), f);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Primary friendly hit %:", 56));
if (stats->p_shots_fired > 0) {
f = (float) stats->p_bonehead_hits * 100.0f / (float) stats->p_shots_fired;
} else {
f = 0.0f;
}
sprintf(Stats[Num_stat_lines], XSTR( "%.1f%%", 55), f);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Secondary weapon shots:", 57));
sprintf(Stats[Num_stat_lines], "%u", stats->s_shots_fired);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Secondary weapon hits:", 58));
sprintf(Stats[Num_stat_lines], "%u", stats->s_shots_hit);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Secondary friendly hits:", 59));
sprintf(Stats[Num_stat_lines], "%u", stats->s_bonehead_hits);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Secondary hit %:", 60));
if (stats->s_shots_fired > 0) {
f = (float) stats->s_shots_hit * 100.0f / (float) stats->s_shots_fired;
} else {
f = 0.0f;
}
sprintf(Stats[Num_stat_lines], XSTR( "%.1f%%", 55), f);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Secondary friendly hit %:", 61));
if (stats->s_shots_fired > 0) {
f = (float) stats->s_bonehead_hits * 100.0f / (float) stats->s_shots_fired;
} else {
f = 0.0f;
}
sprintf(Stats[Num_stat_lines], XSTR( "%.1f%%", 55), f);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Total kills:", 62));
sprintf(Stats[Num_stat_lines], "%d", stats->kill_count_ok);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Assists:", 63));
sprintf(Stats[Num_stat_lines], "%d", stats->assists);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], "Current Score:");
sprintf(Stats[Num_stat_lines], "%d", stats->score);
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "*Kills by Ship Type", 64));
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
Assert(Num_stat_lines < Max_stat_lines);
Stat_labels[Num_stat_lines][0] = 0;
Stats[Num_stat_lines][0] = 0;
Num_stat_lines++;
// Goober5000 - make sure we have room for all ships
Assert((Num_stat_lines + static_cast<int>(Ship_info.size())) < Max_stat_lines);
i = 0;
for (auto it = Ship_info.cbegin(); it != Ship_info.cend(); i++, ++it) {
if (stats->kills[i]) {
Assert(Num_stat_lines < Max_stat_lines);
// Goober5000 - in case above Assert isn't triggered (such as in non-debug builds)
if (Num_stat_lines >= Max_stat_lines)
{
break;
}
Assert(strlen(it->name) + 1 < STAT_COLUMN1_W);
sprintf(Stat_labels[Num_stat_lines], NOX("%s:"), it->name);
sprintf(Stats[Num_stat_lines], "%d", stats->kills[i]);
Num_stat_lines++;
// work out the total score from ship kills
score_from_kills += stats->kills[i] * it->score;
}
}
// add the score from kills
Assert((Num_stat_lines + 1) < Max_stat_lines);
STRCPY1(Stat_labels[Num_stat_lines], XSTR( "Score from kills only:", 1636));
sprintf(Stats[Num_stat_lines], "%d", score_from_kills);
Num_stat_lines++;
for (i=0; i<Num_stat_lines; i++) {
font::force_fit_string(Stat_labels[i], Stat_column1_w[gr_screen.res], Barracks_stats_coords[gr_screen.res][BARRACKS_W_COORD]);
font::force_fit_string(Stats[i], Stat_column2_w[gr_screen.res], Barracks_stats2_coords[gr_screen.res][BARRACKS_W_COORD]);
}
}
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Repetier-Firmware. If not, see <http://www.gnu.org/licenses/>.
This firmware is a nearly complete rewrite of the sprinter firmware
by kliment (https://github.com/kliment/Sprinter)
which based on Tonokip RepRap firmware rewrite based off of Hydra-mmm firmware.
*/
#include "Repetier.h"
#if DRIVE_SYSTEM==3
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Delta EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:2")
#else
#if DRIVE_SYSTEM==0
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Mendel EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:2")
#else
FSTRINGVALUE(Com::tFirmware,"FIRMWARE_NAME:Repetier_" REPETIER_VERSION " FIRMWARE_URL:https://github.com/repetier/Repetier-Firmware/ PROTOCOL_VERSION:1.0 MACHINE_TYPE:Core_XY EXTRUDER_COUNT:" XSTR(NUM_EXTRUDER) " REPETIER_PROTOCOL:2")
#endif
#endif
FSTRINGVALUE(Com::tDebug,"Debug:");
FSTRINGVALUE(Com::tOk,"ok")
FSTRINGVALUE(Com::tNewline,"\r\n")
FSTRINGVALUE(Com::tNAN,"NAN")
FSTRINGVALUE(Com::tINF,"INF")
FSTRINGVALUE(Com::tError,"Error:")
FSTRINGVALUE(Com::tInfo,"Info:")
FSTRINGVALUE(Com::tWarning,"Warning:")
void barracks_delete_pilot()
{
char buf[MAX_FILENAME_LEN];
int active = 0;
int del_rval;
if (!Num_pilots) {
gamesnd_play_iface(SND_GENERAL_FAIL);
return;
}
if (Player_sel_mode == PLAYER_SELECT_MODE_MULTI) {
gamesnd_play_iface(SND_GENERAL_FAIL);
popup(PF_TITLE_BIG | PF_TITLE_RED | PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("Disabled!\n\nMulti and single player pilots are now identical. "
"Deleting a multi-player pilot will also delete all single-player data for that pilot.\n\nAs a safety precaution, pilots can only be "
"deleted from the single-player menu.", 1598));
return;
}
int popup_rval = popup(PF_TITLE_BIG | PF_TITLE_RED, 2, POPUP_NO, POPUP_YES, XSTR( "Warning!\n\nAre you sure you wish to delete this pilot?", 65));
if (popup_rval != 1) {
return;
}
if (!stricmp(Pilots[Selected_line], Cur_pilot->callsign)) {
active = 1;
}
strcpy_s(buf, Pilots[Selected_line]);
del_rval = delete_pilot_file(buf);
if ( !del_rval ) {
popup(PF_USE_AFFIRMATIVE_ICON | PF_TITLE_BIG | PF_TITLE_RED, 1, POPUP_OK, XSTR("Error\nFailed to delete pilot file. File may be read-only.", 1599));
return;
} else {
if (active) {
Cur_pilot->callsign[0] = 0;
}
}
for (int i=Selected_line; i<Num_pilots-1; i++) {
strcpy(Pilots[i], Pilots[i + 1]);
Pilot_ranks[i] = Pilot_ranks[i + 1];
}
Num_pilots--;
if (Selected_line >= Num_pilots) {
Selected_line = Num_pilots - 1;
}
if (active) {
if (Selected_line >= 0) {
barracks_new_pilot_selected();
} else {
Cur_pilot->callsign[0] = 0;
}
}
gamesnd_play_iface(SND_USER_SELECT);
}
static void
gen_exp (rtx x, enum rtx_code subroutine_type, char *used)
{
RTX_CODE code;
int i;
int len;
const char *fmt;
if (x == 0)
{
printf ("NULL_RTX");
return;
}
code = GET_CODE (x);
switch (code)
{
case MATCH_OPERAND:
case MATCH_DUP:
if (used)
{
if (used[XINT (x, 0)])
{
printf ("copy_rtx (operand%d)", XINT (x, 0));
return;
}
used[XINT (x, 0)] = 1;
}
printf ("operand%d", XINT (x, 0));
return;
case MATCH_OP_DUP:
printf ("gen_rtx_fmt_");
for (i = 0; i < XVECLEN (x, 1); i++)
printf ("e");
printf (" (GET_CODE (operand%d), ", XINT (x, 0));
if (GET_MODE (x) == VOIDmode)
printf ("GET_MODE (operand%d)", XINT (x, 0));
else
printf ("%smode", GET_MODE_NAME (GET_MODE (x)));
for (i = 0; i < XVECLEN (x, 1); i++)
{
printf (",\n\t\t");
gen_exp (XVECEXP (x, 1, i), subroutine_type, used);
}
printf (")");
return;
case MATCH_OPERATOR:
printf ("gen_rtx_fmt_");
for (i = 0; i < XVECLEN (x, 2); i++)
printf ("e");
printf (" (GET_CODE (operand%d)", XINT (x, 0));
printf (", %smode", GET_MODE_NAME (GET_MODE (x)));
for (i = 0; i < XVECLEN (x, 2); i++)
{
printf (",\n\t\t");
gen_exp (XVECEXP (x, 2, i), subroutine_type, used);
}
printf (")");
return;
case MATCH_PARALLEL:
case MATCH_PAR_DUP:
printf ("operand%d", XINT (x, 0));
return;
case MATCH_SCRATCH:
gen_rtx_scratch (x, subroutine_type);
return;
case PC:
printf ("pc_rtx");
return;
case RETURN:
printf ("ret_rtx");
return;
case SIMPLE_RETURN:
printf ("simple_return_rtx");
return;
case CLOBBER:
if (REG_P (XEXP (x, 0)))
{
printf ("gen_hard_reg_clobber (%smode, %i)", GET_MODE_NAME (GET_MODE (XEXP (x, 0))),
REGNO (XEXP (x, 0)));
return;
}
break;
case CC0:
printf ("cc0_rtx");
return;
case CONST_INT:
if (INTVAL (x) == 0)
printf ("const0_rtx");
else if (INTVAL (x) == 1)
printf ("const1_rtx");
else if (INTVAL (x) == -1)
printf ("constm1_rtx");
else if (-MAX_SAVED_CONST_INT <= INTVAL (x)
&& INTVAL (x) <= MAX_SAVED_CONST_INT)
printf ("const_int_rtx[MAX_SAVED_CONST_INT + (%d)]",
(int) INTVAL (x));
else if (INTVAL (x) == STORE_FLAG_VALUE)
printf ("const_true_rtx");
else
{
printf ("GEN_INT (");
printf (HOST_WIDE_INT_PRINT_DEC_C, INTVAL (x));
printf (")");
}
return;
case CONST_DOUBLE:
case CONST_FIXED:
case CONST_WIDE_INT:
/* These shouldn't be written in MD files. Instead, the appropriate
routines in varasm.c should be called. */
gcc_unreachable ();
default:
break;
}
printf ("gen_rtx_");
print_code (code);
printf (" (%smode", GET_MODE_NAME (GET_MODE (x)));
fmt = GET_RTX_FORMAT (code);
len = GET_RTX_LENGTH (code);
for (i = 0; i < len; i++)
{
if (fmt[i] == '0')
break;
printf (",\n\t");
switch (fmt[i])
{
case 'e': case 'u':
gen_exp (XEXP (x, i), subroutine_type, used);
break;
case 'i':
printf ("%u", XINT (x, i));
break;
case 's':
printf ("\"%s\"", XSTR (x, i));
break;
case 'E':
{
int j;
printf ("gen_rtvec (%d", XVECLEN (x, i));
for (j = 0; j < XVECLEN (x, i); j++)
{
printf (",\n\t\t");
gen_exp (XVECEXP (x, i, j), subroutine_type, used);
}
printf (")");
break;
}
default:
gcc_unreachable ();
}
}
printf (")");
}
// callback handler for the squadon selection buttons when they are disabled (in single player)
void barracks_squad_change_popup()
{
// show a popup
popup( PF_USE_AFFIRMATIVE_ICON | PF_NO_NETWORKING, 1, POPUP_OK, XSTR("You cannot change your squadron in Single Player mode.", 1445));
}
void
i386_pe_encode_section_info (tree decl, rtx rtl, int first)
{
default_encode_section_info (decl, rtl, first);
if (first && TREE_CODE (decl) == FUNCTION_DECL)
{
tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
tree newid = NULL_TREE;
if (lookup_attribute ("stdcall", type_attributes))
newid = gen_stdcall_or_fastcall_suffix (decl, false);
else if (lookup_attribute ("fastcall", type_attributes))
newid = gen_stdcall_or_fastcall_suffix (decl, true);
if (newid != NULL_TREE)
{
rtx rtlname = XEXP (rtl, 0);
if (GET_CODE (rtlname) == MEM)
rtlname = XEXP (rtlname, 0);
XSTR (rtlname, 0) = IDENTIFIER_POINTER (newid);
/* These attributes must be present on first declaration,
change_decl_assembler_name will warn if they are added
later and the decl has been referenced, but duplicate_decls
should catch the mismatch before this is called. */
change_decl_assembler_name (decl, newid);
}
}
else if (TREE_CODE (decl) == VAR_DECL
&& lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
{
if (DECL_INITIAL (decl)
/* If an object is initialized with a ctor, the static
initialization and destruction code for it is present in
each unit defining the object. The code that calls the
ctor is protected by a link-once guard variable, so that
the object still has link-once semantics, */
|| TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
make_decl_one_only (decl);
else
error ("%q+D:'selectany' attribute applies only to initialized objects",
decl);
}
/* Mark the decl so we can tell from the rtl whether the object is
dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes
handles dllexport/dllimport override semantics. */
if (i386_pe_dllexport_p (decl))
i386_pe_mark_dllexport (decl);
else if (i386_pe_dllimport_p (decl))
i386_pe_mark_dllimport (decl);
/* It might be that DECL has been declared as dllimport, but a
subsequent definition nullified that. Assert that
tree.c: merge_dllimport_decl_attributes has removed the attribute
before the RTL name was marked with the DLL_IMPORT_PREFIX. */
else
gcc_assert (!((TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL)
&& rtl != NULL_RTX
&& GET_CODE (rtl) == MEM
&& GET_CODE (XEXP (rtl, 0)) == MEM
&& GET_CODE (XEXP (XEXP (rtl, 0), 0)) == SYMBOL_REF
&& i386_pe_dllimport_name_p (XSTR (XEXP (XEXP (rtl, 0), 0), 0))));
}
void barracks_button_pressed(int n)
{
switch (n) {
case B_PILOT_SCROLL_UP_BUTTON:
barracks_scroll_callsign_up();
break;
case B_PILOT_SCROLL_DOWN_BUTTON:
barracks_scroll_callsign_down();
break;
case B_STATS_SCROLL_UP_BUTTON:
barracks_scroll_stats_up();
break;
case B_STATS_SCROLL_DOWN_BUTTON:
barracks_scroll_stats_down();
break;
case B_PIC_PREV_PILOT_BUTTON:
barracks_prev_pic();
break;
case B_PIC_NEXT_PILOT_BUTTON:
barracks_next_pic();
break;
case B_SQUAD_PREV_BUTTON:
barracks_prev_squad_pic();
break;
case B_SQUAD_NEXT_BUTTON:
barracks_next_squad_pic();
break;
case B_PILOT_SET_ACTIVE_BUTTON:
if (barracks_new_pilot_selected()){
gamesnd_play_iface(SND_GENERAL_FAIL);
// if it's just the missing campaign file that failed for us then don't give the second popup
if (Campaign_file_missing) {
break;
}
} else {
gamesnd_play_iface(SND_SCROLL);
if (Campaign_file_missing) {
popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR( "The currently active campaign cannot be found. Please select another...", 1600));
gameseq_post_event(GS_EVENT_CAMPAIGN_ROOM);
}
}
break;
case B_ACCEPT_BUTTON:
if (Num_pilots && !barracks_pilot_accepted()) {
gamesnd_play_iface(SND_COMMIT_PRESSED);
if (Campaign_file_missing) {
popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR( "The currently active campaign cannot be found. Please select another...", 1600));
gameseq_post_event(GS_EVENT_CAMPAIGN_ROOM);
} else {
gameseq_post_event(GS_EVENT_MAIN_MENU);
}
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
// if it's just the missing campaign file that failed for us then don't give the second popup
if (Campaign_file_missing) {
break;
}
}
break;
case B_PILOT_CLONE_BUTTON:
if (Num_pilots < 1) {
gamesnd_play_error_beep();
break;
}
Clone_flag = 1;
barracks_create_new_pilot();
break;
case B_PILOT_CONVERT_BUTTON: {
/* New Pilot code no longer needs a conversion function. */
popup(PF_TITLE_BIG | PF_TITLE_BLUE | PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK,
XSTR("Disabled!\n\n\nMulti and Single Player Pilot files are now identical.\n\n"
"Conversion between the two is no longer necessary.", 1601));
/* // no actual conversion with new pilot code
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
barracks_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
} else {
// make sure we don't carry over the multi flag
if (Cur_pilot->flags & PLAYER_FLAGS_IS_MULTI) {
Cur_pilot->flags &= ~PLAYER_FLAGS_IS_MULTI;
}
barracks_init_player_stuff(PLAYER_SELECT_MODE_SINGLE);
}
gamesnd_play_iface(SND_USER_SELECT); */
break;
}
case B_PILOT_CREATE_BUTTON:
Clone_flag = 0;
barracks_create_new_pilot();
break;
case B_HELP_BUTTON:
launch_context_help();
gamesnd_play_iface(SND_HELP_PRESSED);
break;
case B_OPTION_BUTTON:
gamesnd_play_iface(SND_SWITCH_SCREENS);
gameseq_post_event(GS_EVENT_OPTIONS_MENU);
break;
case B_STATS_MEDAL_BUTTON:
gamesnd_play_iface(SND_SWITCH_SCREENS);
gameseq_post_event(GS_EVENT_VIEW_MEDALS);
break;
case B_PILOT_DELETE_BUTTON:
barracks_delete_pilot();
break;
case B_PILOT_SINGLE_MODE_BUTTON:
if (Player_sel_mode != PLAYER_SELECT_MODE_SINGLE) {
gamesnd_play_iface(SND_USER_SELECT);
// make sure we don't carry over the multi flag
if (Cur_pilot->flags & PLAYER_FLAGS_IS_MULTI) {
Cur_pilot->flags &= ~PLAYER_FLAGS_IS_MULTI;
}
Pilot.save_player(Cur_pilot);
barracks_init_player_stuff(PLAYER_SELECT_MODE_SINGLE);
}
break;
case B_PILOT_MULTI_MODE_BUTTON:
if ( Networking_disabled ) {
game_feature_disabled_popup();
break;
}
if (Player_sel_mode != PLAYER_SELECT_MODE_MULTI) {
gamesnd_play_iface(SND_USER_SELECT);
Cur_pilot->flags |= PLAYER_FLAGS_IS_MULTI;
Pilot.save_player(Cur_pilot);
barracks_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
}
break;
}
}
/* ssdpDiscoverDevices() :
* return a chained list of all devices found or NULL if
* no devices was found.
* It is up to the caller to free the chained list
* delay is in millisecond (poll).
* UDA v1.1 says :
* The TTL for the IP packet SHOULD default to 2 and
* SHOULD be configurable. */
struct UPNPDev *
ssdpDiscoverDevices(const char * const deviceTypes[],
int delay, const char * multicastif,
int localport,
int ipv6, unsigned char ttl,
int * error,
int searchalltypes)
{
struct UPNPDev * tmp;
struct UPNPDev * devlist = 0;
unsigned int scope_id = 0;
int opt = 1;
static const char MSearchMsgFmt[] =
"M-SEARCH * HTTP/1.1\r\n"
"HOST: %s:" XSTR(SSDP_PORT) "\r\n"
"ST: %s\r\n"
"MAN: \"ssdp:discover\"\r\n"
"MX: %u\r\n"
"\r\n";
int deviceIndex;
char bufr[1536]; /* reception and emission buffer */
int sudp;
int n;
struct sockaddr_storage sockudp_r;
unsigned int mx;
#ifdef NO_GETADDRINFO
struct sockaddr_storage sockudp_w;
#else
int rv;
struct addrinfo hints, *servinfo, *p;
#endif
#ifdef _WIN32
MIB_IPFORWARDROW ip_forward;
unsigned long _ttl = (unsigned long)ttl;
#endif
int linklocal = 1;
if(error)
*error = MINISSDPC_UNKNOWN_ERROR;
if(localport==UPNP_LOCAL_PORT_SAME)
localport = SSDP_PORT;
#ifdef _WIN32
sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
#else
sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
#endif
if(sudp < 0)
{
if(error)
*error = MINISSDPC_SOCKET_ERROR;
return NULL;
}
/* reception */
memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
if(ipv6) {
struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
p->sin6_family = AF_INET6;
if(localport > 0 && localport < 65536)
p->sin6_port = htons((unsigned short)localport);
p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
} else {
struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
p->sin_family = AF_INET;
if(localport > 0 && localport < 65536)
p->sin_port = htons((unsigned short)localport);
p->sin_addr.s_addr = INADDR_ANY;
}
#ifdef _WIN32
/* This code could help us to use the right Network interface for
* SSDP multicast traffic */
/* Get IP associated with the index given in the ip_forward struct
* in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
if(!ipv6
&& (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {
DWORD dwRetVal = 0;
PMIB_IPADDRTABLE pIPAddrTable;
DWORD dwSize = 0;
#ifdef DEBUG
IN_ADDR IPAddr;
#endif
int i;
#ifdef DEBUG
printf("ifIndex=%lu nextHop=%lx \n", ip_forward.dwForwardIfIndex, ip_forward.dwForwardNextHop);
#endif
pIPAddrTable = (MIB_IPADDRTABLE *) malloc(sizeof (MIB_IPADDRTABLE));
if(pIPAddrTable) {
if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
free(pIPAddrTable);
pIPAddrTable = (MIB_IPADDRTABLE *) malloc(dwSize);
}
}
if(pIPAddrTable) {
dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );
if (dwRetVal == NO_ERROR) {
#ifdef DEBUG
printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
#endif
for (i=0; i < (int) pIPAddrTable->dwNumEntries; i++) {
#ifdef DEBUG
printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex);
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
printf("\tIP Address[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
printf("\tSubnet Mask[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
printf("\tBroadCast[%d]: \t%s (%ld)\n", i, inet_ntoa(IPAddr), pIPAddrTable->table[i].dwBCastAddr);
printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize);
printf("\tType and State[%d]:", i);
printf("\n");
#endif
if (pIPAddrTable->table[i].dwIndex == ip_forward.dwForwardIfIndex) {
/* Set the address of this interface to be used */
struct in_addr mc_if;
memset(&mc_if, 0, sizeof(mc_if));
mc_if.s_addr = pIPAddrTable->table[i].dwAddr;
setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if));
((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = pIPAddrTable->table[i].dwAddr;
#ifndef DEBUG
break;
#endif
}
}
}
free(pIPAddrTable);
pIPAddrTable = NULL;
}
}
#endif /* _WIN32 */
#ifdef _WIN32
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
#else
if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
#endif
{
if(error)
*error = MINISSDPC_SOCKET_ERROR;
closesocket(sudp);
return NULL;
}
#ifdef _WIN32
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, (const char *)&_ttl, sizeof(_ttl)) < 0)
#else /* _WIN32 */
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0)
#endif /* _WIN32 */
{
/* not a fatal error */
}
if(multicastif)
{
if(ipv6) {
#if !defined(_WIN32)
/* according to MSDN, if_nametoindex() is supported since
* MS Windows Vista and MS Windows Server 2008.
* http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(ifindex)) < 0)
{
}
#else
#ifdef DEBUG
printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
#endif
#endif
} else {
struct in_addr mc_if;
mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */
if(mc_if.s_addr != INADDR_NONE)
{
((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
{
}
} else {
#ifdef HAS_IP_MREQN
/* was not an ip address, try with an interface name */
struct ip_mreqn reqn; /* only defined with -D_BSD_SOURCE or -D_GNU_SOURCE */
memset(&reqn, 0, sizeof(struct ip_mreqn));
reqn.imr_ifindex = if_nametoindex(multicastif);
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&reqn, sizeof(reqn)) < 0)
{
}
#elif !defined(_WIN32)
struct ifreq ifr;
int ifrlen = sizeof(ifr);
strncpy(ifr.ifr_name, multicastif, IFNAMSIZ);
ifr.ifr_name[IFNAMSIZ-1] = '\0';
if(ioctl(sudp, SIOCGIFADDR, &ifr, &ifrlen) < 0)
{
}
mc_if.s_addr = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
{
}
#else /* _WIN32 */
#ifdef DEBUG
printf("Setting of multicast interface not supported with interface name.\n");
#endif
#endif /* #ifdef HAS_IP_MREQN / !defined(_WIN32) */
}
}
}
/* Before sending the packed, we first "bind" in order to be able
* to receive the response */
if (bind(sudp, (const struct sockaddr *)&sockudp_r,
ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
{
if(error)
*error = MINISSDPC_SOCKET_ERROR;
closesocket(sudp);
return NULL;
}
if(error)
*error = MINISSDPC_SUCCESS;
/* Calculating maximum response time in seconds */
mx = ((unsigned int)delay) / 1000u;
if(mx == 0) {
mx = 1;
delay = 1000;
}
/* receiving SSDP response packet */
for(deviceIndex = 0; deviceTypes[deviceIndex]; deviceIndex++) {
/* sending the SSDP M-SEARCH packet */
n = snprintf(bufr, sizeof(bufr),
MSearchMsgFmt,
ipv6 ?
(linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")
: UPNP_MCAST_ADDR,
deviceTypes[deviceIndex], mx);
if ((unsigned int)n >= sizeof(bufr)) {
if(error)
*error = MINISSDPC_MEMORY_ERROR;
goto error;
}
#ifdef DEBUG
/*printf("Sending %s", bufr);*/
printf("Sending M-SEARCH request to %s with ST: %s\n",
ipv6 ?
(linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")
: UPNP_MCAST_ADDR,
deviceTypes[deviceIndex]);
#endif
#ifdef NO_GETADDRINFO
/* the following code is not using getaddrinfo */
/* emission */
memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
if(ipv6) {
struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
p->sin6_family = AF_INET6;
p->sin6_port = htons(SSDP_PORT);
inet_pton(AF_INET6,
linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
&(p->sin6_addr));
} else {
struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
p->sin_family = AF_INET;
p->sin_port = htons(SSDP_PORT);
p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
}
n = sendto(sudp, bufr, n, 0, &sockudp_w,
ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
if (n < 0) {
if(error)
*error = MINISSDPC_SOCKET_ERROR;
break;
}
#else /* #ifdef NO_GETADDRINFO */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; /* AF_INET6 or AF_INET */
hints.ai_socktype = SOCK_DGRAM;
/*hints.ai_flags = */
if ((rv = getaddrinfo_retro(ipv6
? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
: UPNP_MCAST_ADDR,
XSTR(SSDP_PORT), &hints, &servinfo)) != 0) {
if(error)
*error = MINISSDPC_SOCKET_ERROR;
#ifdef _WIN32
fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
#else
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
#endif
break;
}
for(p = servinfo; p; p = p->ai_next) {
n = (int)sendto(sudp, bufr, n, 0, p->ai_addr, p->ai_addrlen);
if (n < 0) {
#ifdef DEBUG
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
if (getnameinfo(p->ai_addr, p->ai_addrlen, hbuf, sizeof(hbuf), sbuf,
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
fprintf(stderr, "host:%s port:%s\n", hbuf, sbuf);
}
#endif
continue;
}
}
freeaddrinfo(servinfo);
if(n < 0) {
if(error)
*error = MINISSDPC_SOCKET_ERROR;
break;
}
#endif /* #ifdef NO_GETADDRINFO */
/* Waiting for SSDP REPLY packet to M-SEARCH
* if searchalltypes is set, enter the loop only
* when the last deviceType is reached */
if(!searchalltypes || !deviceTypes[deviceIndex + 1]) do {
n = receivedata(sudp, bufr, sizeof(bufr), delay, &scope_id);
if (n < 0) {
/* error */
if(error)
*error = MINISSDPC_SOCKET_ERROR;
goto error;
} else if (n == 0) {
/* no data or Time Out */
#ifdef DEBUG
printf("NODATA or TIMEOUT\n");
#endif /* DEBUG */
if (devlist && !searchalltypes) {
/* found some devices, stop now*/
if(error)
*error = MINISSDPC_SUCCESS;
goto error;
}
} else {
const char * descURL=NULL;
int urlsize=0;
const char * st=NULL;
int stsize=0;
const char * usn=NULL;
int usnsize=0;
parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize, &usn, &usnsize);
if(st&&descURL) {
#ifdef DEBUG
printf("M-SEARCH Reply:\n ST: %.*s\n USN: %.*s\n Location: %.*s\n",
stsize, st, usnsize, (usn?usn:""), urlsize, descURL);
#endif /* DEBUG */
for(tmp=devlist; tmp; tmp = tmp->pNext) {
if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&
tmp->descURL[urlsize] == '\0' &&
memcmp(tmp->st, st, stsize) == 0 &&
tmp->st[stsize] == '\0' &&
(usnsize == 0 || memcmp(tmp->usn, usn, usnsize) == 0) &&
tmp->usn[usnsize] == '\0')
break;
}
/* at the exit of the loop above, tmp is null if
* no duplicate device was found */
if(tmp)
continue;
tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize+usnsize);
if(!tmp) {
/* memory allocation error */
if(error)
*error = MINISSDPC_MEMORY_ERROR;
goto error;
}
tmp->pNext = devlist;
tmp->descURL = tmp->buffer;
tmp->st = tmp->buffer + 1 + urlsize;
tmp->usn = tmp->st + 1 + stsize;
memcpy(tmp->buffer, descURL, urlsize);
tmp->buffer[urlsize] = '\0';
memcpy(tmp->st, st, stsize);
tmp->buffer[urlsize+1+stsize] = '\0';
if(usn != NULL)
memcpy(tmp->usn, usn, usnsize);
tmp->buffer[urlsize+1+stsize+1+usnsize] = '\0';
tmp->scope_id = scope_id;
devlist = tmp;
}
}
} while(n > 0);
if(ipv6) {
/* switch linklocal flag */
if(linklocal) {
linklocal = 0;
--deviceIndex;
} else {
linklocal = 1;
}
}
}
error:
closesocket(sudp);
return devlist;
}
int main(int argc, char **argv)
{
set_cpu(the_cores[0]);
ssalloc_init();
seeds = seed_rand();
pin(pthread_self(), 0);
#ifdef PAPI
if (PAPI_VER_CURRENT != PAPI_library_init(PAPI_VER_CURRENT))
{
printf("PAPI_library_init error.\n");
return 0;
}
else
{
printf("PAPI_library_init success.\n");
}
if (PAPI_OK != PAPI_query_event(PAPI_L1_DCM))
{
printf("Cannot count PAPI_L1_DCM.");
}
printf("PAPI_query_event: PAPI_L1_DCM OK.\n");
if (PAPI_OK != PAPI_query_event(PAPI_L2_DCM))
{
printf("Cannot count PAPI_L2_DCM.");
}
printf("PAPI_query_event: PAPI_L2_DCM OK.\n");
#endif
struct option long_options[] = {
// These options don't set a flag
{"help", no_argument, NULL, 'h'},
{"num-threads", required_argument, NULL, 'n'},
{"seed", required_argument, NULL, 's'},
{"input-file", required_argument, NULL, 'i'},
{"output-file", required_argument, NULL, 'o'},
{"max-size", required_argument, NULL, 'm'},
{"nothing", required_argument, NULL, 'l'},
{NULL, 0, NULL, 0}
};
sl_intset_t *set;
pq_t *linden_set;
int i, c, size, edges;
unsigned long reads, effreads, updates, collisions, effupds,
add, added, remove, removed;
thread_data_t *data;
pthread_t *threads;
pthread_attr_t attr;
barrier_t barrier;
struct timeval start, end;
int nb_threads = DEFAULT_NB_THREADS;
int seed = DEFAULT_SEED;
int seed2 = DEFAULT_SEED;
int pq = DEFAULT_PQ;
int sl = DEFAULT_SL;
int lin = DEFAULT_LIN;
char *input = "";
char *output = "";
int src = 0;
int max = -1;
int weighted = 0;
int bimodal = 0;
sigset_t block_set;
while(1) {
i = 0;
c = getopt_long(argc, argv, "hplLwbn:s:i:o:m:", long_options, &i);
if(c == -1)
break;
if(c == 0 && long_options[i].flag == 0)
c = long_options[i].val;
switch(c) {
case 0:
break;
case 'h':
printf("SSSP "
"(priority queue)\n"
"\n"
"Usage:\n"
" sssp [options...]\n"
"\n"
"Options:\n"
" -h, --help\n"
" Print this message\n"
" -l, --spray-list\n"
" Remove via delete_min operations using a spray list\n"
" -p, --priority-queue\n"
" Remove via delete_min operations using a skip list\n"
" -L, --linden\n"
" Use Linden's priority queue\n"
" -n, --num-threads <int>\n"
" Number of threads (default=" XSTR(DEFAULT_NB_THREADS) ")\n"
" -s, --seed <int>\n"
" RNG seed (0=time-based, default=" XSTR(DEFAULT_SEED) ")\n"
" -i, --input-file <string>\n"
" file to read the graph from (required) \n"
" -o, --output-file <string>\n"
" file to write the resulting shortest paths to\n"
" -m, --max-size <int>\n"
" if input graph exceeds max-size, use only first max-size nodes\n"
" -w, --weighted\n"
" use random edge weights uniformly chosen in [0,1]; fixed between trials given fixed seed\n"
" -b, --bimodal\n"
" use random edge weights chosen in [20,30]U[70,80]; fixed between trials given fixed seed\n"
);
exit(0);
case 'l':
sl = 1;
break;
case 'p':
pq = 1;
break;
case 'L':
lin = 1;
break;
case 'w':
weighted = 1;
break;
case 'b':
bimodal = 1;
break;
case 'n':
nb_threads = atoi(optarg);
break;
case 's':
seed = atoi(optarg);
break;
case 'i':
input = optarg;
break;
case 'o':
output = optarg;
break;
case 'm':
max = atoi(optarg);
break;
case '?':
printf("Use -h or --help for help\n");
exit(0);
default:
exit(1);
}
}
assert(nb_threads > 0);
if (seed == 0)
srand((int)time(0));
else
srand(seed);
printf("Set type : skip list\n");
printf("Nb threads : %d\n", nb_threads);
printf("Seed : %d\n", seed);
printf("Priority Q : %d\n", pq);
printf("Spray List : %d\n", sl);
printf("Linden : %d\n", lin);
printf("Type sizes : int=%d/long=%d/ptr=%d/word=%d\n",
(int)sizeof(int),
(int)sizeof(long),
(int)sizeof(void *),
(int)sizeof(uintptr_t));
if ((data = (thread_data_t *)malloc(nb_threads * sizeof(thread_data_t))) == NULL) {
perror("malloc");
exit(1);
}
if ((threads = (pthread_t *)malloc(nb_threads * sizeof(pthread_t))) == NULL) {
perror("malloc");
exit(1);
}
// TODO: Build graph here
FILE* fp = fopen(input, "r");
fscanf(fp, "# Nodes: %d Edges: %d\n", &size, &edges);
if (size > max && max != -1) size = max;
#ifndef STATIC
if ((nodes = (graph_node_t*)malloc(size * sizeof(graph_node_t))) == NULL) {
perror("malloc");
exit(1);
}
#endif
for (i = 0;i < size;i++) {
nodes[i].deg = 0;
nodes[i].dist = -1;
nodes[i].times_processed = 0;
}
int u,v;
int cur = 0, count = 0;
while (fscanf(fp, "%d %d\n", &u, &v) == 2) {
if (u >= size) continue;
if (v >= size) continue;
nodes[u].deg++;
}
#ifndef STATIC
for (i = 0;i < size;i++) {
if ((nodes[i].adj = (int*)malloc(nodes[i].deg * sizeof(int))) == NULL) {
perror("malloc");
exit(1);
}
if ((nodes[i].weights = (int*)malloc(nodes[i].deg * sizeof(int))) == NULL) {
perror("malloc");
exit(1);
}
}
#endif
fclose(fp);
nodes[src].dist = 0;
fp = fopen(input, "r");
int tmp;
fscanf(fp, "# Nodes: %d Edges: %d\n", &tmp, &edges);
int *idx;
if ((idx= (int*)malloc(size * sizeof(int))) == NULL) {
perror("malloc");
exit(1);
}
for (i = 0;i < size;i++) {
idx[i] = 0;
}
while (fscanf(fp, "%d %d\n", &u, &v) == 2) {
if (u >= size) continue;
if (v >= size) continue;
assert(idx[u] < nodes[u].deg);
nodes[u].adj[idx[u]] = v;
if (weighted) {
nodes[u].weights[idx[u]] = rand() % 100;
} else if (bimodal) {
if (rand() % 2) {
nodes[u].weights[idx[u]] = (rand() % 11) + 20;
} else {
nodes[u].weights[idx[u]] = (rand() % 11) + 70;
}
} else {
nodes[u].weights[idx[u]] = 1;
}
idx[u]++;
}
free(idx);
// for (u = 0; u < size; u++) {
// for (count = 0; count < nodes[u].deg; count++) {
// printf("%d %d\n", u, nodes[u].adj[count]);
// }
// }
// pq/sl
*levelmax = floor_log_2(size)+2;
set = sl_set_new();
sl_add_val(set, 0, src, TRANSACTIONAL);
// linden
if (lin) {
int offset = 32; // not sure what this does
_init_gc_subsystem();
linden_set = pq_init(offset);
insert(linden_set, 1, src);
nodes[src].dist = 1; // account for the fact that keys must be positive
}
printf("Graph size : %d\n", size);
printf("Level max : %d\n", *levelmax);
// Access set from all threads
barrier_init(&barrier, nb_threads + 1);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
printf("Creating threads: ");
for (i = 0; i < nb_threads; i++)
{
printf("%d, ", i);
data[i].pq = pq;
data[i].sl = sl;
data[i].first_remove = -1;
data[i].nb_collisions = 0;
data[i].nb_add = 0;
data[i].nb_clean = 0;
data[i].nb_added = 0;
data[i].nb_remove = 0;
data[i].nb_removed = 0;
data[i].nb_contains = 0;
data[i].nb_found = 0;
data[i].nb_aborts = 0;
data[i].nb_aborts_locked_read = 0;
data[i].nb_aborts_locked_write = 0;
data[i].nb_aborts_validate_read = 0;
data[i].nb_aborts_validate_write = 0;
data[i].nb_aborts_validate_commit = 0;
data[i].nb_aborts_invalid_memory = 0;
data[i].nb_aborts_double_write = 0;
data[i].max_retries = 0;
data[i].nb_threads = nb_threads;
data[i].seed = rand();
data[i].seed2 = rand();
data[i].set = set;
data[i].barrier = &barrier;
data[i].failures_because_contention = 0;
data[i].id = i;
/* LINDEN */
data[i].lin = lin;
data[i].linden_set = linden_set;
if (pthread_create(&threads[i], &attr, sssp, (void *)(&data[i])) != 0) {
fprintf(stderr, "Error creating thread\n");
exit(1);
}
}
pthread_attr_destroy(&attr);
// Catch some signals
if (signal(SIGHUP, catcher) == SIG_ERR ||
//signal(SIGINT, catcher) == SIG_ERR ||
signal(SIGTERM, catcher) == SIG_ERR) {
perror("signal");
exit(1);
}
/* stop = 0; */
*running = 1;
// Start threads
barrier_cross(&barrier);
printf("STARTING...\n");
gettimeofday(&start, NULL);
// Wait for thread completion
for (i = 0; i < nb_threads; i++) {
if (pthread_join(threads[i], NULL) != 0) {
fprintf(stderr, "Error waiting for thread completion\n");
exit(1);
}
}
gettimeofday(&end, NULL);
printf("STOPPING...\n");
long nb_processed = 0;
long unreachable = 0;
if (strcmp(output,"")) {
FILE *out = fopen(output, "w");
for (i = 0;i < size;i++) {
fprintf(out, "%d %d\n", i, nodes[i].dist);
}
fclose(out);
} else {
for (i = 0;i < size;i++) {
printf("%d %d\n", i, nodes[i].dist);
}
}
for (i = 0;i < size;i++) {
nb_processed += nodes[i].times_processed;
if (nodes[i].times_processed == 0) {
unreachable++;
}
}
int duration = (end.tv_sec * 1000 + end.tv_usec / 1000) - (start.tv_sec * 1000 + start.tv_usec / 1000);
printf ("duration = %d\n", duration);
reads = 0;
effreads = 0;
updates = 0;
collisions = 0;
add = 0;
added = 0;
remove = 0;
removed = 0;
effupds = 0;
for (i = 0; i < nb_threads; i++) {
printf("Thread %d\n", i);
printf(" #add : %lu\n", data[i].nb_add);
printf(" #added : %lu\n", data[i].nb_added);
printf(" #remove : %lu\n", data[i].nb_remove);
printf(" #removed : %lu\n", data[i].nb_removed);
printf(" #cleaned : %lu\n", data[i].nb_clean);
printf(" #collisions : %lu\n", data[i].nb_collisions);
printf(" #contains : %lu\n", data[i].nb_contains);
printf(" #found : %lu\n", data[i].nb_found);
reads += data[i].nb_contains;
effreads += data[i].nb_contains +
(data[i].nb_add - data[i].nb_added) +
(data[i].nb_remove - data[i].nb_removed);
updates += (data[i].nb_add + data[i].nb_remove);
collisions += data[i].nb_collisions;
add += data[i].nb_add;
added += data[i].nb_added;
remove += data[i].nb_remove;
removed += data[i].nb_removed;
effupds += data[i].nb_removed + data[i].nb_added;
size += data[i].nb_added - data[i].nb_removed;
}
printf("Set size : %d (expected: %d)\n", sl_set_size(set), size);
printf("nodes processed:%d\n", nb_processed);
printf("unreachable : %d\n", unreachable);
printf("wasted work : %d\n", nb_processed - (size - unreachable));
printf("Duration : %d (ms)\n", duration);
printf("#ops : %lu (%f / s)\n", reads + updates, (reads + updates) * 1000.0 / duration);
printf("#read ops : ");
printf("%lu (%f / s)\n", reads, reads * 1000.0 / duration);
printf("#eff. upd rate: %f \n", 100.0 * effupds / (effupds + effreads));
printf("#update ops : ");
printf("%lu (%f / s)\n", updates, updates * 1000.0 / duration);
printf("#total_remove : %lu\n", remove);
printf("#total_removed: %lu\n", removed);
printf("#total_add : %lu\n", add);
printf("#total_added : %lu\n", added);
printf("#net (rem-add): %lu\n", removed-added);
printf("#total_collide: %lu\n", collisions);
printf("#norm_collide : %f\n", ((double)collisions)/removed);
#ifdef PRINT_END
print_skiplist(set);
#endif
#ifdef PAPI
long total_L1_miss = 0;
unsigned k = 0;
for (k = 0; k < nb_threads; k++) {
total_L1_miss += g_values[k][0];
total_L2_miss += g_values[k][1];
//printf("[Thread %d] L1_DCM: %lld\n", i, g_values[i][0]);
//printf("[Thread %d] L2_DCM: %lld\n", i, g_values[i][1]);
}
printf("\n#L1 Cache Misses: %lld\n", total_L1_miss);
printf("#Normalized Cache Misses: %f\n", ((double)total_L1_miss)/(reads+updates));
printf("\n#L2 Cache Misses: %lld\n", total_L2_miss);
printf("#Normalized Cache Misses: %f\n", ((double)total_L1_miss)/(reads+updates));
#endif
// Delete set
if (pq || sl) {
sl_set_delete(set);
}
free(threads);
free(data);
return 0;
}
