static void print_ecmd(char *cmd, int *args, int narg)
{
#if 1
char *p;
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
sprintf(p, "^%s(", cmd);
if(*args == WRD_NOARG)
strcat(p, "*");
else
sprintf(p + strlen(p), "%d", *args);
args++;
narg--;
while(narg > 0)
{
if(*args == WRD_NOARG)
strcat(p, ",*");
else
sprintf(p + strlen(p), ",%d", *args);
args++;
narg--;
}
strcat(p, ")");
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
#endif
}
void wrd_add_path(char *path, int pathlen)
{
if(pathlen == 0)
pathlen = strlen(path);
if(!wrd_add_path_one(path, pathlen))
return;
if(current_file_info &&
get_archive_type(current_file_info->filename) != -1)
{
MBlockList buf;
char *arc_path;
int baselen;
init_mblock(&buf);
baselen = strrchr(current_file_info->filename, '#') -
current_file_info->filename + 1;
arc_path = new_segment(&buf, baselen + pathlen + 1);
strncpy(arc_path, current_file_info->filename, baselen);
strncpy(arc_path + baselen, path, pathlen);
arc_path[baselen + pathlen] = '\0';
put_string_table(&path_list, arc_path, strlen(arc_path));
reuse_mblock(&buf);
}
}
/*
* segment_get(name) - lookup named segment
TODO: move to segment private functions?
*/
segment_t *segment_get(char *name)
{
glctx_t *gcp = &glctx;
segment_t *segp, **segpp;
for (segpp = gcp->seglist; (segp = *segpp); ++segpp) {
if (segp->seg_type == SEGT_NONE) {
if (gcp->seg_avail == NULL)
gcp->seg_avail = *segpp;
continue;
}
if (!strcmp(name, segp->seg_name))
return segp;
}
if (gcp->seg_avail == NULL && segpp < &gcp->seglist[MAX_SEGMENTS]) {
/*
* prealloc an available segment
*/
*segpp = segp = new_segment();
if (segp != NULL) {
segp->seg_slot = segpp - gcp->seglist;
gcp->seg_avail = segp;
}
}
return NULL;
}
/*
* Used by Extreme Binning.
*/
static struct segment* segment_file_defined(struct chunk *c) {
static struct segment* tmp;
/*
* For file-defined segmenting,
* the end is not a new segment.
*/
if (tmp == NULL)
tmp = new_segment();
if (c == NULL)
return tmp;
g_sequence_append(tmp->chunks, c);
if (CHECK_CHUNK(c, CHUNK_FILE_END)) {
struct segment* ret = tmp;
tmp = NULL;
return ret;
} else if (CHECK_CHUNK(c, CHUNK_FILE_START)) {
return NULL;
} else {
/* a normal chunk */
tmp->chunk_num++;
return NULL;
}
}
/*
* get_seg_slot() -- allocate a segment table slot for a new segment
*/
static segment_t *get_seg_slot(void)
{
glctx_t *gcp = &glctx;
segment_t *segp, **segpp;
/*
* consume saved slot, if any
*/
segp = gcp->seg_avail;
if (segp != NULL) {
gcp->seg_avail = NULL;
return segp;
}
/*
* simple linear scan for first available slot
*/
for (segpp = gcp->seglist; (segp = *segpp); ++segpp) {
if (segp->seg_type == SEGT_NONE)
return segp;
}
if (segpp < &gcp->seglist[MAX_SEGMENTS]) {
/*
* previously unused slot
*/
*segpp = segp = new_segment();
segp->seg_slot = segpp - gcp->seglist;
return segp;
}
fprintf(stderr, "%s: segment table full\n", gcp->program_name);
return NULL;
}
/*
* Used by SiLo and Block Locality Caching.
*/
static struct segment* segment_fixed(struct chunk * c) {
static struct segment* tmp;
if (tmp == NULL)
tmp = new_segment();
if (c == NULL)
/* The end of stream */
return tmp;
g_sequence_append(tmp->chunks, c);
if (CHECK_CHUNK(c, CHUNK_FILE_START)
|| CHECK_CHUNK(c, CHUNK_FILE_END))
/* FILE_END */
return NULL;
/* a normal chunk */
tmp->chunk_num++;
if (tmp->chunk_num == destor.index_segment_algorithm[1]) {
/* segment boundary */
struct segment* ret = tmp;
tmp = NULL;
return ret;
}
return NULL;
}
static int cmsg(int type, int verbosity_level, char *fmt, ...) {
va_list ap;
char *buff;
MBlockList pool;
if ((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) &&
ctl.verbosity<verbosity_level)
return 0;
va_start(ap, fmt);
if(!xaw_ready) {
vfprintf(stderr, fmt, ap);
fprintf(stderr, NLS);
va_end(ap);
return 0;
}
init_mblock(&pool);
buff = (char *)new_segment(&pool, MIN_MBLOCK_SIZE);
vsnprintf(buff, MIN_MBLOCK_SIZE, fmt, ap);
a_pipe_write_msg(buff);
reuse_mblock(&pool);
va_end(ap);
return 0;
}
void print_ecmd(char *cmd, int *args, int narg)
{
char *p;
size_t s = MIN_MBLOCK_SIZE;
p = (char *)new_segment(&tmpbuffer, s);
snprintf(p, s, "^%s(", cmd);
if(*args == WRD_NOARG)
strncat(p, "*", s - strlen(p) - 1);
else {
char c[CHAR_BIT*sizeof(int)];
snprintf(c, sizeof(c)-1, "%d", args[0]);
strncat(p, c, s - strlen(p) - 1);
}
args++;
narg--;
while(narg > 0)
{
if(*args == WRD_NOARG)
strncat(p, ",*", s - strlen(p) - 1);
else {
char c[CHAR_BIT*sizeof(int)]; /* should be enough loong */
snprintf(c, sizeof(c)-1, ",%d", args[0]);
strncat(p, c, s - strlen(p) - 1);
}
args++;
narg--;
}
strncat(p, ")", s - strlen(p) - 1);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
}
void transform_segment(SEGMENT *segment, int num_segment, SEGMENT *insertreg, int num_insertreg)
{
int i, j, k, l;
for(i = 0; i < num_segment; i ++) {
new_segment(segment[i].chro, segment[i].pos, insertreg, num_insertreg);
}
}
/** @brief What to do when an incoming segment arrives to an established connection? **/
inline static int handle_established_connection ( pntoh_tcp_session_t session , pntoh_tcp_stream_t stream , struct tcphdr *tcp , size_t payload_len , pntoh_tcp_peer_t origin , pntoh_tcp_peer_t destination , void *udata, int who )
{
pntoh_tcp_segment_t segment = 0;
unsigned long seq = ntohl(tcp->th_seq) - origin->isn;
unsigned long ack = ntohl(tcp->th_ack) - origin->ian;
/* only store segments with data */
if ( payload_len > 0 )
{
if (stream->enable_check_nowindow) {
/* if we have no space */
while ( origin->totalwin < payload_len && send_peer_segments ( session , stream , origin , destination , ack , 1 , NTOH_REASON_NOWINDOW, who ) > 0 );
/* we're in trouble */
if ( origin->totalwin < payload_len )
return NTOH_NO_WINDOW_SPACE_LEFT;
}
/* creates a new segment and push it into the queue */
segment = new_segment ( seq , ack , payload_len , tcp->th_flags , udata );
queue_segment ( session , origin , segment );
}
/* ACK the segments of the other side */
if ( tcp->th_flags & TH_ACK )
send_peer_segments ( session , stream , destination , origin , ack , 0 , 0, !who );
/* wants to close the connection */
if ( ( tcp->th_flags & (TH_FIN | TH_RST) ) && origin->final_seq == 0 )
origin->final_seq = seq;
/* the segment has been not queued and it is a synchronization segment */
if ( origin->final_seq > 0 && origin->final_seq <= seq && !segment )
{
segment = new_segment ( seq , ack , payload_len , tcp->th_flags , udata );
if ( ! origin->segments )
handle_closing_connection ( session , stream , origin , destination , segment, who );
else
queue_segment ( session , origin , segment );
}
return NTOH_OK;
}
static mlval *next_box(void)
{
if (root_table == NULL)
{ /* Initialise empty root_table */
root_table = new_segment();
};
return( scan_for_box(root_table) );
}
/*
* Used by Sparse Index.
*/
static struct segment* segment_content_defined(struct chunk *c) {
static struct segment* tmp;
if (tmp == NULL)
tmp = new_segment();
if (c == NULL)
/* The end of stream */
return tmp;
if (CHECK_CHUNK(c, CHUNK_FILE_START) || CHECK_CHUNK(c, CHUNK_FILE_END)) {
g_sequence_append(tmp->chunks, c);
return NULL;
}
/* Avoid too small segment. */
if (tmp->chunk_num < destor.index_segment_min) {
g_sequence_append(tmp->chunks, c);
tmp->chunk_num++;
return NULL;
}
int *head = (int*)&c->fp[16];
if ((*head) % destor.index_segment_algorithm[1] == 0) {
struct segment* ret = tmp;
tmp = new_segment();
g_sequence_append(tmp->chunks, c);
tmp->chunk_num++;
return ret;
}
g_sequence_append(tmp->chunks, c);
tmp->chunk_num++;
if (tmp->chunk_num >= destor.index_segment_max){
struct segment* ret = tmp;
tmp = new_segment();
return ret;
}
return NULL;
}
static mlval *scan_for_box(segment *current)
{ int top, i;
mlval *table, *box;
for(;;){
if (current -> vacant > 0){
top = current -> top;
table = current -> table;
if (top >= 0)
{ if (table[top] == FREE) {
box = &table[top];
current -> top--;
current -> vacant--;
return(box);
}
else current -> top = -1;
};
/* Now scan table (upwards) for free elements ... */
for (i=0; i < ROOT_TABLE_SIZE; i++){
if (table[i] == FREE)
{ current -> vacant--;
return(&table[i]);
};
};
};
/* There's no free elements in this segment ... so try next one */
/* But first check if you have reached the end ... */
if (current -> next_seg == NULL)
{ /* Add fresh segment to the root table and set
* current segment also. Doing this will create
* something to be found.
*/
current = new_segment();
}
else { current = current -> next_seg; };
};
return(NULL); /* NOT REACHED */
}
static void
translate_common (gfc_common_head *common, gfc_symbol *var_list)
{
gfc_symbol *sym;
current_common = NULL;
current_offset = 0;
/* Add symbols to the segment. */
for (sym = var_list; sym; sym = sym->common_next)
{
if (! sym->equiv_built)
new_segment (common, sym);
}
create_common (common);
}
static struct timidity_file *try_wrd_open_file(char *prefix, char *fn)
{
MBlockList buf;
char *path;
int len1, len2;
struct timidity_file *tf;
init_mblock(&buf);
len1 = strlen(prefix);
len2 = strlen(fn);
path = (char *)new_segment(&buf, len1 + len2 + 2);
strcpy(path, prefix);
if( len1>0 && path[len1 - 1] != '#' && !IS_PATH_SEP(path[len1 - 1]))
{
path[len1++] = PATH_SEP;
path[len1] = '\0';
}
strcat(path, fn);
tf = open_file(path, 0, OF_SILENT);
reuse_mblock(&buf);
return tf;
}
static NOINLINE void *
find_segment(struct alloc_ptr *ptr)
{
unsigned int blocksize_log2 = ALLOC_PTR_TO_BLOCKSIZE_LOG2(ptr);
struct segment *seg;
struct subheap *subheap = &global_subheaps[blocksize_log2];
void *obj;
ASSERT(BLOCKSIZE_MIN_LOG2 <= blocksize_log2
&& blocksize_log2 <= BLOCKSIZE_MAX_LOG2);
UNRESERVED_NEXT(subheap->unreserved, seg);
if (seg) {
/* seg have at least one free block. */
set_alloc_ptr(ptr, seg);
obj = find_bitmap(ptr);
ASSERT(obj != NULL);
GCSTAT_COUNT_MOVE(find[blocksize_log2], next[blocksize_log2]);
return obj;
}
seg = new_segment();
if (seg) {
init_segment(seg, blocksize_log2);
UNRESERVED_APPEND(subheap->unreserved, seg);
set_alloc_ptr(ptr, seg);
ASSERT(!BITPTR_TEST(ptr->freebit));
GCSTAT_ALLOC_COUNT(new, blocksize_log2, ptr->blocksize_bytes);
BITPTR_INC(ptr->freebit);
obj = ptr->free;
ptr->free += ptr->blocksize_bytes;
return obj;
}
return NULL;
}
static void wrdt_apply(int cmd, int wrd_argc, int wrd_args[])
{
char *p;
char *text;
int i, len;
if(cmd == WRD_MAGPRELOAD)
return; /* Load MAG file */
if(cmd == WRD_PHOPRELOAD)
return; /* Load PHO file - Not implemented */
if(inkey_flag)
printf("* ");
switch(cmd)
{
case WRD_LYRIC:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", text);
reuse_mblock(&tmpbuffer);
break;
case WRD_NL: /* Newline (Ignored) */
break;
case WRD_COLOR:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@COLOR(%d)", wrd_args[0]);
break;
case WRD_END: /* Never call */
break;
case WRD_ESC:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@ESC(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_EXEC:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@EXEC(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_FADE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@FADE(%d,%d,%d)", wrd_args[0], wrd_args[1], wrd_args[2]);
break;
case WRD_FADESTEP:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@FADESTEP(%d/%d)", wrd_args[0], WRD_MAXFADESTEP);
break;
case WRD_GCIRCLE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GCIRCLE(%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5]);
break;
case WRD_GCLS:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GCLS(%d)", wrd_args[0]);
break;
case WRD_GINIT:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@GINIT()");
break;
case WRD_GLINE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GLINE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6]);
break;
case WRD_GMODE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GMODE(%d)", wrd_args[0]);
break;
case WRD_GMOVE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GMOVE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6], wrd_args[7], wrd_args[8]);
break;
case WRD_GON:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GON(%d)", wrd_args[0]);
break;
case WRD_GSCREEN:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GSCREEN(%d,%d)", wrd_args[0], wrd_args[1]);
break;
case WRD_INKEY:
inkey_flag = 1;
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@INKEY - begin");
break;
case WRD_OUTKEY:
inkey_flag = 0;
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@INKEY - end");
break;
case WRD_LOCATE:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@LOCATE(%d,%d)", wrd_args[0], wrd_args[1]);
break;
case WRD_LOOP: /* Never call */
break;
case WRD_MAG:
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
snprintf(p, MIN_MBLOCK_SIZE-1, "@MAG(%s", wrd_event2string(wrd_args[0]));
p[MIN_MBLOCK_SIZE-1] = '\0'; /* fail safe */
for(i = 1; i < 5; i++)
{
if(wrd_args[i] == WRD_NOARG)
strncat(p, ",*", MIN_MBLOCK_SIZE - strlen(p) - 1);
else {
char q[CHAR_BIT*sizeof(int)];
snprintf(q, sizeof(q)-1, ",%d", wrd_args[i]);
strncat(p, q, MIN_MBLOCK_SIZE - strlen(p) - 1);
}
}
strncat(p, ")", MIN_MBLOCK_SIZE - strlen(p) - 1);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
break;
case WRD_MIDI: /* Never call */
break;
case WRD_OFFSET: /* Never call */
break;
case WRD_PAL:
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
snprintf(p, MIN_MBLOCK_SIZE, "@PAL(%03x", wrd_args[0]);
for(i = 1; i < 17; i++) {
char q[5];
snprintf(q, sizeof(q)-1, ",%03x", wrd_args[i]);
strncat(p, q, MIN_MBLOCK_SIZE - strlen(p) - 1);
}
strncat(p, ")", MIN_MBLOCK_SIZE - strlen(p) - 1);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
break;
case WRD_PALCHG:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PALCHG(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_PALREV:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PALREV(%d)", wrd_args[0]);
break;
case WRD_PATH:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PATH(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_PLOAD:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PLOAD(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_REM:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@REM %s", text);
reuse_mblock(&tmpbuffer);
break;
case WRD_REMARK:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@REMARK(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_REST: /* Never call */
break;
case WRD_SCREEN: /* Not supported */
break;
case WRD_SCROLL:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@SCROLL(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5], wrd_args[6]);
break;
case WRD_STARTUP:
inkey_flag = 0;
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@STARTUP(%d)", wrd_args[0]);
break;
case WRD_STOP: /* Never call */
break;
case WRD_TCLS:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@TCLS(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5]);
break;
case WRD_TON:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@TON(%d)", wrd_args[0]);
break;
case WRD_WAIT: /* Never call */
break;
case WRD_WMODE: /* Never call */
break;
/* Ensyutsukun */
case WRD_eFONTM:
print_ecmd("FONTM", wrd_args, 1);
break;
case WRD_eFONTP:
print_ecmd("FONTP", wrd_args, 4);
break;
case WRD_eFONTR:
print_ecmd("FONTR", wrd_args, 17);
break;
case WRD_eGSC:
print_ecmd("GSC", wrd_args, 1);
break;
case WRD_eLINE:
print_ecmd("LINE", wrd_args, 1);
break;
case WRD_ePAL:
print_ecmd("PAL", wrd_args, 2);
break;
case WRD_eREGSAVE:
print_ecmd("REGSAVE", wrd_args, 17);
break;
case WRD_eSCROLL:
print_ecmd("SCROLL",wrd_args, 2);
break;
case WRD_eTEXTDOT:
print_ecm
/** @brief API for add an incoming segment **/
int ntoh_tcp_add_segment ( pntoh_tcp_session_t session , pntoh_tcp_stream_t stream , struct ip *ip , size_t len , void *udata )
{
size_t iphdr_len = 0;
size_t tcphdr_len = 0;
size_t payload_len = 0;
struct tcphdr *tcp = 0;
pntoh_tcp_peer_t origin = 0;
pntoh_tcp_peer_t destination = 0;
unsigned int tstamp = 0;
int ret = NTOH_OK;
pntoh_tcp_segment_t segment = 0;
int who;
if ( !stream || !session )
return NTOH_ERROR_PARAMS;
/* verify IP header */
if ( !ip ) // no ip header
return NTOH_INCORRECT_IPHEADER;
if ( len <= sizeof(struct ip) ) // no data
return NTOH_INCORRECT_LENGTH;
if ( ( iphdr_len = 4 * ( ip->ip_hl ) ) < sizeof(struct ip) ) // incorrect ip header length
return NTOH_INCORRECT_IP_HEADER_LENGTH;
if ( len < ntohs( ip->ip_len ) ) // incorrect capture length
return NTOH_NO_ENOUGH_DATA;
if ( ip->ip_v != 4 ) // only handle IPv4
return NTOH_NOT_IPV4;
/* check IP addresses */
if ( !(
( stream->client.addr == ip->ip_src.s_addr && stream->server.addr == ip->ip_dst.s_addr ) ||
( stream->client.addr == ip->ip_dst.s_addr && stream->server.addr == ip->ip_src.s_addr )
))
return NTOH_IP_ADDRESSES_MISMATCH;
if ( ip->ip_p != IPPROTO_TCP )
return NTOH_NOT_TCP;
tcp = (struct tcphdr*) ( (unsigned char*)ip + iphdr_len );
/* check TCP header */
if ( ( tcphdr_len = tcp->th_off * 4 ) < sizeof(struct tcphdr) )
return NTOH_INCORRECT_TCP_HEADER_LENGTH;
if ( !tcp->th_flags || tcp->th_flags == 0xFF )
return NTOH_INVALID_FLAGS;
lock_access ( &stream->lock );
/* check TCP ports */
if ( !(
( tcp->th_dport == stream->tuple.dport && tcp->th_sport == stream->tuple.sport ) ||
( tcp->th_dport == stream->tuple.sport && tcp->th_sport == stream->tuple.dport )
))
return NTOH_TCP_PORTS_MISMATCH;
payload_len = ntohs(ip->ip_len) - iphdr_len - tcphdr_len;
/* get origin and destination */
if ( stream->tuple.source == ip->ip_src.s_addr )
{
origin = &stream->client;
destination = &stream->server;
who = NTOH_SENT_BY_CLIENT;
}else{
origin = &stream->server;
destination = &stream->client;
who = NTOH_SENT_BY_SERVER;
}
get_timestamp ( tcp , tcphdr_len , &tstamp );
/* PAWS check */
if ( tstamp > 0 && origin->lastts > 0 )
{
if ( tstamp < origin->lastts )
{
ret = NTOH_PAWS_FAILED;
goto exitp;
}
if ( ntohl(tcp->th_seq) <= origin->next_seq )
origin->lastts = tstamp;
}else if ( tstamp > 0 && !(origin->lastts) )
origin->lastts = tstamp;
if ( origin->next_seq > 0 && (origin->isn - ntohl ( tcp->th_seq ) ) < origin->next_seq )
{
ret = NTOH_TOO_LOW_SEQ_NUMBER;
goto exitp;
}
if ( destination->next_seq > 0 && (origin->ian - ntohl(tcp->th_ack) ) < destination->next_seq )
{
ret = NTOH_TOO_LOW_ACK_NUMBER;
goto exitp;
}
/* @todo some TCP/IP stacks implementations overloads the MSS on certain segments */
/*if ( origin->mss > 0 && payload_len > origin->mss )
return NTOH_SEGMENT_EXCEEDS_MSS;*/
/* switch between connection status */
switch ( stream->status )
{
case NTOH_STATUS_CLOSED:
case NTOH_STATUS_SYNSENT:
case NTOH_STATUS_SYNRCV:
if ( payload_len > 0 )
{
ret = NTOH_HANDSHAKE_FAILED;
goto exitp;
}
ret = handle_new_connection ( stream , tcp , origin , destination , udata );
if ( ret == NTOH_OK )
{
if ( origin->receive )
{
if ( stream->status == NTOH_STATUS_ESTABLISHED )
((pntoh_tcp_callback_t)stream->function) ( stream , origin , destination , 0 , NTOH_REASON_SYNC , NTOH_REASON_ESTABLISHED );
else
((pntoh_tcp_callback_t)stream->function) ( stream , origin , destination , 0 , NTOH_REASON_SYNC , NTOH_REASON_SYNC );
}
}else{
lock_access ( &session->lock );
delete_stream ( session , &stream , NTOH_REASON_SYNC , ret );
unlock_access ( &session->lock );
}
break;
case NTOH_STATUS_ESTABLISHED:
ret = handle_established_connection ( session , stream , tcp , payload_len , origin , destination , udata, who );
break;
default:
segment = new_segment( ntohl ( tcp->th_seq ) - origin->isn , ntohl ( tcp->th_ack ) - origin->ian , payload_len , tcp->th_flags , udata );
handle_closing_connection ( session , stream , origin , destination , segment, who );
if ( stream->status == NTOH_STATUS_CLOSED )
{
lock_access ( &session->lock );
__tcp_free_stream ( session , &stream , NTOH_REASON_SYNC , NTOH_REASON_CLOSED );
unlock_access ( &session->lock );
stream = 0;
}
break;
}
if ( ret == NTOH_OK )
{
if ( stream != 0 )
gettimeofday ( & (stream->last_activ) , 0 );
if ( payload_len == 0 )
ret = NTOH_SYNCHRONIZING;
}
exitp:
if ( stream != 0 )
unlock_access ( &stream->lock );
return ret;
}
/*
* When a container buffer is full, we push it into container_queue.
*/
static void* filter_thread(void *arg) {
int enable_rewrite = 1;
struct fileRecipeMeta* r = NULL;
while (1) {
struct chunk* c = sync_queue_pop(rewrite_queue);
if (c == NULL)
/* backup job finish */
break;
/* reconstruct a segment */
struct segment* s = new_segment();
/* segment head */
assert(CHECK_CHUNK(c, CHUNK_SEGMENT_START));
free_chunk(c);
c = sync_queue_pop(rewrite_queue);
while (!(CHECK_CHUNK(c, CHUNK_SEGMENT_END))) {
g_sequence_append(s->chunks, c);
if (!CHECK_CHUNK(c, CHUNK_FILE_START)
&& !CHECK_CHUNK(c, CHUNK_FILE_END))
s->chunk_num++;
c = sync_queue_pop(rewrite_queue);
}
free_chunk(c);
/* For self-references in a segment.
* If we find an early copy of the chunk in this segment has been rewritten,
* the rewrite request for it will be denied to avoid repeat rewriting. */
GHashTable *recently_rewritten_chunks = g_hash_table_new_full(g_int64_hash,
g_fingerprint_equal, NULL, free_chunk);
GHashTable *recently_unique_chunks = g_hash_table_new_full(g_int64_hash,
g_fingerprint_equal, NULL, free_chunk);
pthread_mutex_lock(&index_lock.mutex);
TIMER_DECLARE(1);
TIMER_BEGIN(1);
/* This function will check the fragmented chunks
* that would be rewritten later.
* If we find an early copy of the chunk in earlier segments,
* has been rewritten,
* the rewrite request for it will be denied. */
index_check_buffer(s);
GSequenceIter *iter = g_sequence_get_begin_iter(s->chunks);
GSequenceIter *end = g_sequence_get_end_iter(s->chunks);
for (; iter != end; iter = g_sequence_iter_next(iter)) {
c = g_sequence_get(iter);
if (CHECK_CHUNK(c, CHUNK_FILE_START) || CHECK_CHUNK(c, CHUNK_FILE_END))
continue;
VERBOSE("Filter phase: %dth chunk in %s container %lld", chunk_num,
CHECK_CHUNK(c, CHUNK_OUT_OF_ORDER) ? "out-of-order" : "", c->id);
/* Cache-Aware Filter */
if (destor.rewrite_enable_cache_aware && restore_aware_contains(c->id)) {
assert(c->id != TEMPORARY_ID);
VERBOSE("Filter phase: %dth chunk is cached", chunk_num);
SET_CHUNK(c, CHUNK_IN_CACHE);
}
/* A cfl-switch for rewriting out-of-order chunks. */
if (destor.rewrite_enable_cfl_switch) {
double cfl = restore_aware_get_cfl();
if (enable_rewrite && cfl > destor.rewrite_cfl_require) {
VERBOSE("Filter phase: Turn OFF the (out-of-order) rewrite switch of %.3f",
cfl);
enable_rewrite = 0;
} else if (!enable_rewrite && cfl < destor.rewrite_cfl_require) {
VERBOSE("Filter phase: Turn ON the (out-of-order) rewrite switch of %.3f",
cfl);
enable_rewrite = 1;
}
}
if(CHECK_CHUNK(c, CHUNK_DUPLICATE) && c->id == TEMPORARY_ID){
struct chunk* ruc = g_hash_table_lookup(recently_unique_chunks, &c->fp);
assert(ruc);
c->id = ruc->id;
}
struct chunk* rwc = g_hash_table_lookup(recently_rewritten_chunks, &c->fp);
if(rwc){
c->id = rwc->id;
SET_CHUNK(c, CHUNK_REWRITE_DENIED);
}
/* A fragmented chunk will be denied if it has been rewritten recently */
if (!CHECK_CHUNK(c, CHUNK_DUPLICATE) || (!CHECK_CHUNK(c, CHUNK_REWRITE_DENIED)
&& (CHECK_CHUNK(c, CHUNK_SPARSE)
|| (enable_rewrite && CHECK_CHUNK(c, CHUNK_OUT_OF_ORDER)
&& !CHECK_CHUNK(c, CHUNK_IN_CACHE))))) {
/*
* If the chunk is unique, or be fragmented and not denied,
* we write it to a container.
* Fragmented indicates: sparse, or out of order and not in cache,
*/
if (storage_buffer.container_buffer == NULL){
storage_buffer.container_buffer = create_container();
if(destor.index_category[1] == INDEX_CATEGORY_PHYSICAL_LOCALITY)
storage_buffer.chunks = g_sequence_new(free_chunk);
}
if (container_overflow(storage_buffer.container_buffer, c->size)) {
if(destor.index_category[1] == INDEX_CATEGORY_PHYSICAL_LOCALITY){
/*
* TO-DO
* Update_index for physical locality
*/
GHashTable *features = sampling(storage_buffer.chunks,
g_sequence_get_length(storage_buffer.chunks));
index_update(features, get_container_id(storage_buffer.container_buffer));
g_hash_table_destroy(features);
g_sequence_free(storage_buffer.chunks);
storage_buffer.chunks = g_sequence_new(free_chunk);
}
TIMER_END(1, jcr.filter_time);
write_container_async(storage_buffer.container_buffer);
TIMER_BEGIN(1);
storage_buffer.container_buffer = create_container();
}
if(add_chunk_to_container(storage_buffer.container_buffer, c)){
struct chunk* wc = new_chunk(0);
memcpy(&wc->fp, &c->fp, sizeof(fingerprint));
wc->id = c->id;
if (!CHECK_CHUNK(c, CHUNK_DUPLICATE)) {
jcr.unique_chunk_num++;
jcr.unique_data_size += c->size;
g_hash_table_insert(recently_unique_chunks, &wc->fp, wc);
VERBOSE("Filter phase: %dth chunk is recently unique, size %d", chunk_num,
g_hash_table_size(recently_unique_chunks));
} else {
jcr.rewritten_chunk_num++;
jcr.rewritten_chunk_size += c->size;
g_hash_table_insert(recently_rewritten_chunks, &wc->fp, wc);
}
if(destor.index_category[1] == INDEX_CATEGORY_PHYSICAL_LOCALITY){
struct chunk* ck = new_chunk(0);
memcpy(&ck->fp, &c->fp, sizeof(fingerprint));
g_sequence_append(storage_buffer.chunks, ck);
}
VERBOSE("Filter phase: Write %dth chunk to container %lld",
chunk_num, c->id);
}else{
VERBOSE("Filter phase: container %lld already has this chunk", c->id);
assert(destor.index_category[0] != INDEX_CATEGORY_EXACT
|| destor.rewrite_algorithm[0]!=REWRITE_NO);
}
}else{
if(CHECK_CHUNK(c, CHUNK_REWRITE_DENIED)){
VERBOSE("Filter phase: %lldth fragmented chunk is denied", chunk_num);
}else if (CHECK_CHUNK(c, CHUNK_OUT_OF_ORDER)) {
VERBOSE("Filter phase: %lldth chunk in out-of-order container %lld is already cached",
chunk_num, c->id);
}
}
assert(c->id != TEMPORARY_ID);
/* Collect historical information. */
har_monitor_update(c->id, c->size);
/* Restore-aware */
restore_aware_update(c->id, c->size);
chunk_num++;
}
int full = index_update_buffer(s);
/* Write a SEGMENT_BEGIN */
segmentid sid = append_segment_flag(jcr.bv, CHUNK_SEGMENT_START, s->chunk_num);
/* Write recipe */
iter = g_sequence_get_begin_iter(s->chunks);
end = g_sequence_get_end_iter(s->chunks);
for (; iter != end; iter = g_sequence_iter_next(iter)) {
c = g_sequence_get(iter);
if(r == NULL){
assert(CHECK_CHUNK(c,CHUNK_FILE_START));
r = new_file_recipe_meta(c->data);
}else if(!CHECK_CHUNK(c,CHUNK_FILE_END)){
struct chunkPointer cp;
cp.id = c->id;
assert(cp.id>=0);
memcpy(&cp.fp, &c->fp, sizeof(fingerprint));
cp.size = c->size;
append_n_chunk_pointers(jcr.bv, &cp ,1);
r->chunknum++;
r->filesize += c->size;
jcr.chunk_num++;
jcr.data_size += c->size;
}else{
assert(CHECK_CHUNK(c,CHUNK_FILE_END));
append_file_recipe_meta(jcr.bv, r);
free_file_recipe_meta(r);
r = NULL;
jcr.file_num++;
}
}
/* Write a SEGMENT_END */
append_segment_flag(jcr.bv, CHUNK_SEGMENT_END, 0);
if(destor.index_category[1] == INDEX_CATEGORY_LOGICAL_LOCALITY){
/*
* TO-DO
* Update_index for logical locality
*/
s->features = sampling(s->chunks, s->chunk_num);
if(destor.index_category[0] == INDEX_CATEGORY_EXACT){
/*
* For exact deduplication,
* unique fingerprints are inserted.
*/
VERBOSE("Filter phase: add %d unique fingerprints to %d features",
g_hash_table_size(recently_unique_chunks),
g_hash_table_size(s->features));
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, recently_unique_chunks);
while(g_hash_table_iter_next(&iter, &key, &value)){
struct chunk* uc = value;
fingerprint *ft = malloc(sizeof(fingerprint));
memcpy(ft, &uc->fp, sizeof(fingerprint));
g_hash_table_insert(s->features, ft, NULL);
}
/*
* OPTION:
* It is still an open problem whether we need to update
* rewritten fingerprints.
* It would increase index update overhead, while the benefit
* remains unclear.
* More experiments are required.
*/
VERBOSE("Filter phase: add %d rewritten fingerprints to %d features",
g_hash_table_size(recently_rewritten_chunks),
g_hash_table_size(s->features));
g_hash_table_iter_init(&iter, recently_rewritten_chunks);
while(g_hash_table_iter_next(&iter, &key, &value)){
struct chunk* uc = value;
fingerprint *ft = malloc(sizeof(fingerprint));
memcpy(ft, &uc->fp, sizeof(fingerprint));
g_hash_table_insert(s->features, ft, NULL);
}
}
index_update(s->features, sid);
}
free_segment(s);
if(index_lock.wait_threshold > 0 && full == 0){
pthread_cond_broadcast(&index_lock.cond);
}
TIMER_END(1, jcr.filter_time);
pthread_mutex_unlock(&index_lock.mutex);
g_hash_table_destroy(recently_rewritten_chunks);
g_hash_table_destroy(recently_unique_chunks);
}
if (storage_buffer.container_buffer
&& !container_empty(storage_buffer.container_buffer)){
if(destor.index_category[1] == INDEX_CATEGORY_PHYSICAL_LOCALITY){
/*
* TO-DO
* Update_index for physical locality
*/
GHashTable *features = sampling(storage_buffer.chunks,
g_sequence_get_length(storage_buffer.chunks));
index_update(features, get_container_id(storage_buffer.container_buffer));
g_hash_table_destroy(features);
g_sequence_free(storage_buffer.chunks);
}
write_container_async(storage_buffer.container_buffer);
}
/* All files done */
jcr.status = JCR_STATUS_DONE;
return NULL;
}
static void wrdt_apply(int cmd, int wrd_argc, int wrd_args[])
{
char *p;
char *text;
int i, len;
static int txtclr_preserve=0;
#if 0
if(inkey_flag)
printf("* ");
#endif
switch(cmd)
{
case WRD_LYRIC:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
/*This must be not good thing,but as far as I know no wrd file
written in EUC-JP code found*/
code_convert(p, text, SAFE_CONVERT_LENGTH(len), "SJIS", (char *)-1);
printf("%s",text);
fflush(stdout);
reuse_mblock(&tmpbuffer);
break;
case WRD_NL: /* Newline (Ignored) */
putchar('\n');
break;
case WRD_COLOR:
txtclr_preserve=wrd_args[0];
if(16 <= txtclr_preserve && txtclr_preserve <= 23)
txtclr_preserve = wrd_color_remap[txtclr_preserve - 16] + 30;
printf("\033[%dm", txtclr_preserve);
break;
case WRD_END: /* Never call */
break;
case WRD_ESC:
printf("\033[%s", wrd_event2string(wrd_args[0]));
break;
case WRD_EXEC:
/*I don't spaun another program*/
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@EXEC(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_FADE:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@FADE(%d,%d,%d)", wrd_args[0], wrd_args[1], wrd_args[2]);
break;
case WRD_FADESTEP:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@FADESTEP(%d/%d)", wrd_args[0], WRD_MAXFADESTEP);
break;
case WRD_GCIRCLE:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GCIRCLE(%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5]);
break;
case WRD_GCLS:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GCLS(%d)", wrd_args[0]);
break;
case WRD_GINIT:
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "@GINIT()");
break;
case WRD_GLINE:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GLINE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6]);
fflush(stdout);
break;
case WRD_GMODE:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GMODE(%d)", wrd_args[0]);
break;
case WRD_GMOVE:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GMOVE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6], wrd_args[7], wrd_args[8]);
break;
case WRD_GON:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GON(%d)", wrd_args[0]);
break;
case WRD_GSCREEN:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@GSCREEN(%d,%d)", wrd_args[0], wrd_args[1]);
break;
case WRD_INKEY:
inkey_flag = 1;
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "@INKEY - begin");
break;
case WRD_OUTKEY:
inkey_flag = 0;
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "@INKEY - end");
break;
case WRD_LOCATE:
printf("\033[%d;%dH", wrd_args[1], wrd_args[0]);
break;
case WRD_LOOP: /* Never call */
break;
case WRD_MAG:
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
strcpy(p, "@MAG(");
strcat(p, wrd_event2string(wrd_args[0]));
strcat(p, ",");
for(i = 1; i < 3; i++)
{
if(wrd_args[i] == WRD_NOARG)
strcat(p, "*,");
else
sprintf(p + strlen(p), "%d,", wrd_args[i]);
}
sprintf(p + strlen(p), "%d,%d)", wrd_args[3], wrd_args[4]);
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "%s", p);
reuse_mblock(&tmpbuffer);
break;
case WRD_MIDI: /* Never call */
break;
case WRD_OFFSET: /* Never call */
break;
case WRD_PAL:
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
sprintf(p, "@PAL(%03x", wrd_args[0]);
for(i = 1; i < 17; i++)
sprintf(p + strlen(p), ",%03x", wrd_args[i]);
strcat(p, ")");
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "%s", p);
reuse_mblock(&tmpbuffer);
break;
case WRD_PALCHG:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@PALCHG(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_PALREV:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@PALREV(%d)", wrd_args[0]);
break;
case WRD_PATH:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@PATH(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_PLOAD:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@PLOAD(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_REM:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
ctl->cmsg(CMSG_INFO, VERB_DEBUG, "@REM %s", text);
reuse_mblock(&tmpbuffer);
break;
case WRD_REMARK:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@REMARK(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_REST: /* Never call */
break;
case WRD_SCREEN: /* Not supported */
break;
case WRD_SCROLL:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@SCROLL(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5], wrd_args[6]);
break;
case WRD_STARTUP:
inkey_flag = 0;
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@STARTUP(%d)", wrd_args[0]);
printf("\033[0m\033[H\033[J");
fflush(stdout);
break;
case WRD_STOP: /* Never call */
break;
case WRD_TCLS:
{
char fillbuf[1024];
fillbuf[0]=0x1b;
fillbuf[1]='7';
fillbuf[2]=0;
printf(fillbuf);
/* 0-7: normal, 8-16: reverse */
if(wrd_args[4] <= 7)
wrd_args[4] += 30;
else
wrd_args[4] += 32;
printf("\033[%dm",wrd_args[4]);
memset(fillbuf,wrd_args[5],wrd_args[2]-wrd_args[0]);/*X2-X1*/
fillbuf[wrd_args[2]-wrd_args[0]]=0;
for(i=wrd_args[1];i<=wrd_args[3];i++)/*Y1 to Y2*/
printf("\033[%d;%dH%s",i,wrd_args[0],fillbuf);/*X1to....*/
fillbuf[0]=0x1b;
fillbuf[1]='8';
fillbuf[2]=0;
printf(fillbuf);
printf("\033[%dm",txtclr_preserve);
fflush(stdout);
}
#if 0
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@TCLS(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5]);
#endif
break;
case WRD_TON:
ctl->cmsg(CMSG_INFO, VERB_DEBUG,
"@TON(%d)", wrd_args[0]);
break;
case WRD_WAIT: /* Never call */
break;
case WRD_WMODE: /* Never call */
break;
/* Ensyutsukun */
case WRD_eFONTM:
break;
case WRD_eFONTP:
break;
case WRD_eFONTR:
break;
case WRD_eGSC:
break;
case WRD_eLINE:
break;
case WRD_ePAL:
break;
case WRD_eREGSAVE:
break;
case WRD_eSCROLL:
break;
case WRD_eTEXTDOT:
break;
case WRD_eTMODE:
break;
case WRD_eTSCRL:
break;
case WRD_eVCOPY:
break;
case WRD_eVSGET:
break;
case WRD_eVSRES:
break;
case WRD_eXCOPY:
break;
default:
break;
}
wrd_argc = 0;
}
QuadrilateralPolar2D_Segment QuadrilateralPolar2D_Segmentation::make_segment()
{
QuadrilateralPolar2D_Segment_t seg = segmentation.make_segment();
QuadrilateralPolar2D_Segment new_segment(seg, *this);
return new_segment;
}
void w32g_update_playlist(void)
{
#if 0
int i, cur, modified;
HWND hListBox;
if(!(hListBox = playlist_box()))
return;
cur = ListBox_GetCurSel(hListBox);
modified = 0;
for(i = 0; i < playlist.nfiles; i++)
{
char *filename, *title, *item1, *item2;
int maxlen, item2_len;
filename = playlist.list[i].filename;
title = playlist.list[i].title;
if(title == NULL || title[0] == '\0')
{
if(playlist.list[i].info->file_type == IS_ERROR_FILE)
title = " --SKIP-- ";
else
title = " -------- ";
}
maxlen = strlen(filename) + strlen(title) + 32;
item1 = (char *)new_segment(&tmpbuffer, maxlen);
if(i == playlist.selected)
snprintf(item1, maxlen, "==>%04d %s (%s)", i + 1, title, filename);
else
snprintf(item1, maxlen, " %04d %s (%s)", i + 1, title, filename);
item2_len = ListBox_GetTextLen(hListBox, i);
item2 = (char *)new_segment(&tmpbuffer, item2_len + 1);
ListBox_GetText(hListBox, i, item2);
if(strcmp(item1, item2) != 0)
{
ListBox_DeleteString(hListBox, i);
ListBox_InsertString(hListBox, i, item1);
modified = 1;
}
reuse_mblock(&tmpbuffer);
}
if(modified)
{
if(cur < 0)
cur = playlist.selected;
else if(cur >= playlist.nfiles - 1)
cur = playlist.nfiles - 1;
ListBox_SetCurSel(hListBox, cur);
SetNumListWnd(cur,playlist.nfiles);
}
#else
int i, cur, modified;
HWND hListBox;
if(!(hListBox = playlist_box()))
return;
cur = ListBox_GetCurSel(hListBox);
modified = 0;
for(i = 0; i < playlist.nfiles; i++)
{
w32g_update_playlist_pos(i);
}
if(modified)
{
if(cur < 0)
cur = playlist.selected;
else if(cur >= playlist.nfiles - 1)
cur = playlist.nfiles - 1;
ListBox_SetCurSel(hListBox, cur);
SetNumListWnd(cur,playlist.nfiles);
}
#endif
}
QuadrilateralCartesian3D_Segment QuadrilateralCartesian3D_Segmentation::make_segment()
{
QuadrilateralCartesian3D_Segment_t seg = segmentation.make_segment();
QuadrilateralCartesian3D_Segment new_segment(seg, *this);
return new_segment;
}
QuadrilateralSpherical3D_Segment QuadrilateralSpherical3D_Segmentation::make_segment()
{
QuadrilateralSpherical3D_Segment_t seg = segmentation.make_segment();
QuadrilateralSpherical3D_Segment new_segment(seg, *this);
return new_segment;
}
// #define WRD_VERBOSE
static void wrdt_apply(int cmd, int wrd_argc, int wrd_args[])
{
char *p;
char *text;
int i, len;
static txtclr_preserve=0;
if ( !w32g_wrd_wnd.active ) return;
switch(cmd)
{
case WRD_LYRIC:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
/*This must be not good thing,but as far as I know no wrd file
written in EUC-JP code found*/
strcpy(text,p);
#ifdef WRD_VERBOSE
// ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
// "[WRD_LYRIC]\n%s", text );
#endif
putstring_with_esc(text);
reuse_mblock(&tmpbuffer);
break;
case WRD_NL: /* Newline (Ignored) */
esc_nextline();
// putchar('\n');
break;
case WRD_COLOR:
/*Compatibility Hack,This remaps color(17-29 color seems
to be ignored in kterm)*/
esc_characterattribute(wrd_args[0]);
break;
case WRD_END: /* Never call */
break;
case WRD_ESC:
borlandc_esc(wrd_event2string(wrd_args[0]));
break;
case WRD_EXEC:
/*I don't spaun another program*/
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@EXEC(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_FADE:
wrd_graphic_fade ( wrd_args[0], wrd_args[1], wrd_args[2] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@FADE(%d,%d,%d)", wrd_args[0], wrd_args[1], wrd_args[2]);
#endif
break;
case WRD_FADESTEP:
wrd_graphic_fadestep ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@FADESTEP(%d/%d)", wrd_args[0], WRD_MAXFADESTEP);
#endif
break;
case WRD_GCIRCLE:
wrd_graphic_gcircle ( wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5] );
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GCIRCLE(%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5]);
break;
case WRD_GCLS:
wrd_graphic_gcls ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GCLS(%d)", wrd_args[0]);
#endif
break;
case WRD_GINIT:
wrd_graphic_ginit ();
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@GINIT()");
#endif
break;
case WRD_GLINE:
wrd_graphic_gline ( wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GLINE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6]);
#endif
break;
case WRD_GMODE:
wrd_graphic_gmode ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GMODE(%d)", wrd_args[0]);
#endif
break;
case WRD_GMOVE:
wrd_graphic_gmove ( wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6], wrd_args[7], wrd_args[8] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GMOVE(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4],
wrd_args[5], wrd_args[6], wrd_args[7], wrd_args[8]);
#endif
break;
case WRD_GON:
wrd_graphic_gon ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GON(%d)", wrd_args[0]);
#endif
break;
case WRD_GSCREEN:
wrd_graphic_gscreen ( wrd_args[0], wrd_args[1] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@GSCREEN(%d,%d)", wrd_args[0], wrd_args[1]);
#endif
break;
case WRD_INKEY:
inkey_flag = 1;
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@INKEY - begin");
break;
case WRD_OUTKEY:
inkey_flag = 0;
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@INKEY - end");
break;
case WRD_LOCATE:
{
int x = wrd_args[0], y = wrd_args[1];
WrdWndGoto(x-1, y-1);
}
break;
case WRD_LOOP: /* Never call */
break;
case WRD_MAG:
wrd_graphic_mag ( wrd_event2string(wrd_args[0]), wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4]);
#ifdef WRD_VERBOSE
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
strcpy(p, "@MAG(");
strcat(p, wrd_event2string(wrd_args[0]));
strcat(p, ",");
for(i = 1; i < 3; i++)
{
if(wrd_args[i] == WRD_NOARG)
strcat(p, "*,");
else
sprintf(p + strlen(p), "%d,", wrd_args[i]);
}
sprintf(p + strlen(p), "%d,%d)", wrd_args[3], wrd_args[4]);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
#endif
break;
case WRD_MIDI: /* Never call */
break;
case WRD_OFFSET: /* Never call */
break;
case WRD_PAL:
wrd_graphic_pal_g4r4b4 (wrd_args[0], wrd_args + 1, 16 );
#ifdef WRD_VERBOSE
p = (char *)new_segment(&tmpbuffer, MIN_MBLOCK_SIZE);
sprintf(p, "@PAL(%03x", wrd_args[0]);
for(i = 1; i < 17; i++)
sprintf(p + strlen(p), ",%03x", wrd_args[i]);
strcat(p, ")");
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "%s", p);
reuse_mblock(&tmpbuffer);
#endif
break;
case WRD_PALCHG:
wrd_graphic_apply_pal ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PALCHG(%s)", wrd_event2string(wrd_args[0]));
#endif
break;
case WRD_PALREV:
wrd_graphic_palrev ( wrd_args[0] );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PALREV(%d)", wrd_args[0]);
#endif
break;
case WRD_PATH:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PATH(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_PLOAD:
wrd_graphic_pload ( wrd_event2string(wrd_args[0]) );
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@PLOAD(%s)", wrd_event2string(wrd_args[0]));
#endif
break;
case WRD_REM:
p = wrd_event2string(wrd_args[0]);
len = strlen(p);
text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len));
code_convert(p, text, SAFE_CONVERT_LENGTH(len), NULL, NULL);
ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "@REM %s", text);
reuse_mblock(&tmpbuffer);
break;
case WRD_REMARK:
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@REMARK(%s)", wrd_event2string(wrd_args[0]));
break;
case WRD_REST: /* Never call */
break;
case WRD_SCREEN: /* Not supported */
break;
case WRD_SCROLL:
wrd_text_scroll (wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5], wrd_args[6]);
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@SCROLL(%d,%d,%d,%d,%d,%d,%d)",
wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3],
wrd_args[4], wrd_args[5], wrd_args[6]);
#endif
break;
case WRD_STARTUP:
WrdWndReset ();
inkey_flag = 0;
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@STARTUP(%d)", wrd_args[0]);
#endif
esc_clearscreen();
break;
case WRD_STOP: /* Never call */
break;
case WRD_TCLS:
{
char fillbuf[1024];
{
int left = wrd_args[0], right = wrd_args[2];
int top = wrd_args[1], bottom = wrd_args[3];
SEIKIX(left);
SEIKIX(right);
SEIKIY(top);
SEIKIY(bottom);
if(left>right) right = left;
if(top>bottom) bottom = top;
memset(fillbuf,wrd_args[5],right-left);/*X2-X1*/
fillbuf[right-left]=0;
// borlandc_con_save_attr();
esc_characterattribute(wrd_args[4]);
for(i=top;i<=bottom;i++)/*Y1 to Y2*/ {
WrdWndGoto(left-1,i-1);
putstring(fillbuf);
}
// borlandc_con_restore_attr();
}
}
break;
case WRD_TON:
wrd_text_ton ( wrd_args[0] );
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"@TON(%d)", wrd_args[0]);
break;
case WRD_WAIT: /* Never call */
break;
case WRD_WMODE: /* Never call */
break;
/* Ensyutsukun */
case WRD_eFONTM:
print_ecmd("FONTM", wrd_args, 1);
break;
case WRD_eFONTP:
print_ecmd("FONTP", wrd_args, 4);
break;
case WRD_eFONTR:
print_ecmd("FONTR", wrd_args, 17);
break;
case WRD_eGSC:
print_ecmd("GSC", wrd_args, 1);
break;
case WRD_eLINE:
print_ecmd("LINE", wrd_args, 1);
break;
case WRD_ePAL:
print_ecmd("PAL", wrd_args, 2);
break;
case WRD_eREGSAVE:
print_ecmd("REGSAVE", wrd_args, 17);
break;
case WRD_eSCROLL:
print_ecmd("SCROLL",wrd_args, 2);
break;
case WRD_eTEXTDOT:
print_ecmd("TEXTDOT", wrd_args, 1);
break;
case WRD_eTMODE:
print_ecmd("TMODE", wrd_args, 1);
break;
case WRD_eTSCRL:
print_ecmd("TSCRL", wrd_args, 0);
break;
case WRD_eVCOPY:
print_ecmd("VCOPY", wrd_args, 9);
break;
case WRD_eVSGET:
print_ecmd("VSGE", wrd_args, 4);
break;
case WRD_eVSRES:
print_ecmd("VSRES", wrd_args, 0);
break;
case WRD_eXCOPY:
wrd_graphic_xcopy ( wrd_args[0], wrd_args[1], wrd_args[2], wrd_args[3], wrd_args[4], wrd_args[5], wrd_args[6],
wrd_args[7], wrd_args[8], wrd_args[9], wrd_args[10], wrd_args[11], wrd_args[12], wrd_args[13] );
print_ecmd("XCOPY", wrd_args, 14);
break;
case WRD_START_SKIP:
wrd_start_skip ();
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"WRD_START_SKIP");
#endif
break;
case WRD_END_SKIP:
wrd_end_skip ();
#ifdef WRD_VERBOSE
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
"WRD_END_SKIP");
#endif
break;
/* Extensionals */
}
}
struct segment* new_segment_full(){
struct segment* s = new_segment();
s->features = g_hash_table_new_full((GHashFunc)g_feature_hash, (GEqualFunc)g_feature_equal, free, NULL);
return s;
}
