struct deplist *deplist_from_deprow(char *deprow)
{
struct deplist *d = NULL;
if (strlen(deprow) <= 0)
return (NULL);
deprow = sedchr(deprow, ',', ' ');
if (!strlen(deprow) > 0)
return d;
while (strstr(deprow, " "))
deprow = sed(deprow, " ", " ");
struct list *deps = NULL;
deps = split(deprow, " ");
while (deps != NULL) {
trim(deps->data);
d = deplist_add(deps->data, d);
deps = deps->next;
}
return (d);
}
struct repolist *parse_cvsup(char *path, struct repolist *r)
{
FILE *file;
char *line = NULL;
size_t n = 0;
ssize_t nread;
file = fopen(path, "r");
if (file == NULL)
return (r);
char *prefix = NULL;
char *mad_prefix = NULL;
char *repo;
while ((nread = getline(&line, &n, file)) != -1) {
line[strlen(line) - 1] = '\0';
trim(line);
if (line[0] == '#' || strlen(line) == 0)
continue;
if (strstr(line, "*default prefix")) {
prefix = get_value(line, "*default prefix");
if (prefix == NULL)
continue;
if (strlen(prefix) <= strlen(PORTS_LOCATION))
continue;
if (strncmp
(prefix, PORTS_LOCATION,
strlen(PORTS_LOCATION)))
continue;
mad_prefix =
mid(prefix, strlen(PORTS_LOCATION) + 1, END);
trim(mad_prefix);
strcat(mad_prefix, "/");
prefix = strdup(PORTS_LOCATION);
}
if (line[0] == '*')
continue;
if (strlen(line)) {
if (mad_prefix) {
repo = strdup(mad_prefix);
strcat(repo, line);
sed(repo, "//", "/");
} else
repo = strdup(line);
strtok(repo, " ");
r = repolist_add(repo, prefix, path, r);
}
}
if (line)
free(line);
fclose(file);
return (r);
}
static char * SED1() {
CPU *c = getCPU();
OP_CODE_INFO *o = getOP_CODE_INFO(0, 0, modeImplied);
sed(c,o);
mu_assert("SED1 err, DEC != 1", getFlag(c,D) == 1);
freeOP_CODE_INFO(o);
free(c);
return 0;
}
const unsigned char *MPEGDescriptor::FindBestMatch(
const desc_list_t &parsed, uint desc_tag, QMap<uint,uint> &langPrefs)
{
uint match_idx = 0;
uint match_pri = UINT_MAX;
int unmatched_idx = -1;
uint i = (desc_tag == DescriptorID::short_event) ? 0 : parsed.size();
for (; i < parsed.size(); i++)
{
if (DescriptorID::short_event == parsed[i][0])
{
ShortEventDescriptor sed(parsed[i]);
QMap<uint,uint>::const_iterator it =
langPrefs.find(sed.CanonicalLanguageKey());
if ((it != langPrefs.end()) && (*it < match_pri))
{
match_idx = i;
match_pri = *it;
}
if (unmatched_idx < 0)
unmatched_idx = i;
}
}
if (match_pri != UINT_MAX)
return parsed[match_idx];
if ((desc_tag == DescriptorID::short_event) && (unmatched_idx >= 0))
{
ShortEventDescriptor sed(parsed[unmatched_idx]);
langPrefs[sed.CanonicalLanguageKey()] = maxPriority(langPrefs) + 1;
return parsed[unmatched_idx];
}
return NULL;
}
/**
* Generate custom footer.
*/
const char *
gen_insert_footer(int place)
{
static FILE *ip;
if (ip != NULL) {
rewind(ip);
} else {
ip = fopen(insert_footer, "r");
if (ip == NULL)
die("cannot open include footer file '%s'.", insert_footer);
}
return sed(ip, place);
}
struct repolist *parse_rsync(char *path, struct repolist *r)
{
FILE *file;
file = fopen(path, "r");
if (file == NULL)
return (r);
char *line = NULL;
size_t n = 0;
ssize_t nread;
while ((nread = getline(&line, &n, file)) != -1) {
char *prefix;
char *mad_prefix = NULL;
char *repo;
line[strlen(line) - 1] = '\0';
trim(line);
if (line[0] == '#' || strlen(line) == 0)
continue;
if (strstr(line, "destination") == NULL)
continue;
repo = get_value(line, "destination");
prefix = strdup(repo);
repo = rindex(repo, '/');
repo = mid(repo, 1, END);
prefix = mid(prefix, 0, strlen(prefix) - strlen(repo));
if (strncmp
(prefix, PORTS_LOCATION,
strlen(PORTS_LOCATION)) == 0
&& strlen(prefix) > strlen(PORTS_LOCATION) + 1) {
mad_prefix =
mid(prefix, strlen(PORTS_LOCATION) + 1, END);
strcat(mad_prefix, "/");
prefix = strdup(PORTS_LOCATION);
repo = strcat(mad_prefix, repo);
sed(repo, "//", "/");
}
r = repolist_add(repo, prefix, path, r);
fclose(file);
return (r);
}
fclose(file);
return (r);
}
struct pkglist *get_favorite(int favorite)
{
FILE *file;
char *filename = "";
struct pkglist *p = NULL;
if (favorite == FAVORITE_REPO)
filename = strdup("/etc/ports/favoriterepo");
else
filename = strdup("/etc/ports/favoriteversion");
file = fopen(filename, "r");
if (file == NULL)
return (NULL);
size_t n = 0;
char *line = NULL;
int nread;
struct list *favoriterow = NULL;
while ((nread = getline(&line, &n, file)) > 0) {
trim(line);
if ((strcmp(line, "") == 0) || (line[0] == '#'))
continue;
sedchr(line, '\t', ' ');
while (strstr(line, " "))
sed(line, " ", " ");
favoriterow = split(line, " ");
trim(favoriterow->next->data);
p = pkglist_add_ordered(favoriterow->data,
favoriterow->next->data,
favoriterow->next->data, NULL, p);
/*for(i=0;i<3;i++)
if(favoriterow[i])
free(favoriterow[i]); */
}
if (line)
free(line);
if (filename)
free(filename);
return (p);
}
struct repolist *repolist_add(char *name, char *path, char *supfile, struct repolist *r)
{
struct repolist *raus = NULL;
raus = (struct repolist *) malloc(sizeof(struct repolist));
strcpy(raus->name, name);
strcpy(raus->path, path);
while(strstr(raus->name, "//"))
strcpy(raus->name, sed(raus->name, "//", "/"));
raus->supfile = (char *) malloc(strlen(supfile) + 1);
strcpy(raus->supfile, supfile);
if (r == NULL) {
r = raus;
r->next = NULL;
} else {
raus->next = r;
r = raus;
}
return (r);
}
//Computes the area and the centroid for a given label
bool GetStats(cv::Mat LabelIm, int i, int j, cv::Mat BinImPad, std::vector<int> &one_stat){
//Seed with the first pixel
std::pair<int,int> seed(i,j);
std::vector< std::pair<int,int> > indices, queueue;
indices.push_back(seed); queueue.push_back(seed);
BIP(i,j) = 0;
double x_men = 0, y_men = 0; //centroid
//Find indices of all pixels with the same label
while( !queueue.empty() ){
std::pair<int, int> index = queueue.back();
queueue.pop_back();
//Check 8-neighborhood
for( int k=-1; k<2; ++k )
for( int l=-1; l<2; ++l )
if( (k==0) && (l==0) ) continue;
else{
if( BIP( (index.first+k),(index.second+l) ) ){
std::pair<int,int> sed( (index.first+k),(index.second+l) );
queueue.push_back( sed );
indices.push_back( sed );
LabelIm.at<unsigned char>( sed.first, sed.second ) = BIP( sed.first,sed.second );
BIP( sed.first, sed.second ) = 0;
x_men += sed.first;
y_men += sed.second;
}
}
}
x_men = round(x_men/((double)indices.size()));
y_men = round(y_men/((double)indices.size()));
one_stat[1] = indices.size();
one_stat[2] = (int)x_men;
one_stat[3] = (int)y_men;
if( (indices.size())>=15 ){ return true; }
else{
std::vector< std::pair<int,int> >::iterator it;
for( it=indices.begin() ; it < indices.end(); ++it )
LabelIm.at<unsigned char>(it->first, it->second) = 0;
return false;
}
}
struct deplist *deplist_from_deprow(char *deprow){
struct deplist *d=NULL;
if (strlen (deprow) > 0) {
char tmp[MASSIMO];
strcpy (deprow, sed (deprow, " ", ","));
while (strlen (deprow) > 0) {
if (strstr (deprow, ",")) {
strcpy (tmp, strstr (deprow, ","));
strcpy (tmp, mid (deprow, 0, strlen (deprow) - strlen (tmp)));
strcpy (deprow, mid (strstr (deprow, ","), 1, FINE));
} else {
strcpy (tmp, deprow);
strcpy (deprow, "");
}
strcpy (tmp, trim (tmp));
if(strlen(trim(tmp))>0)
d=add (trim(tmp), d);
strcpy (deprow, trim (deprow));
}
}
return(d);
}
int main(int argc,char *argv[])
{
sed(argc,argv);
return 0;
}
/**
* @brief emulate instruction
* @return returns false if something goes wrong (e.g. illegal instruction)
*
* Current limitations:
*
* - Illegal instructions are not implemented
* - Excess cycles due to page boundary crossing are not calculated
* - Some known architectural bugs are not emulated
*/
bool Cpu::emulate()
{
/* fetch instruction */
uint8_t insn = fetch_op();
bool retval = true;
/* emulate instruction */
switch(insn)
{
/* BRK */
case 0x0: brk(); break;
/* ORA (nn,X) */
case 0x1: ora(load_byte(addr_indx()),6); break;
/* ORA nn */
case 0x5: ora(load_byte(addr_zero()),3); break;
/* ASL nn */
case 0x6: asl_mem(addr_zero(),5); break;
/* PHP */
case 0x8: php(); break;
/* ORA #nn */
case 0x9: ora(fetch_op(),2); break;
/* ASL A */
case 0xA: asl_a(); break;
/* ORA nnnn */
case 0xD: ora(load_byte(addr_abs()),4); break;
/* ASL nnnn */
case 0xE: asl_mem(addr_abs(),6); break;
/* BPL nn */
case 0x10: bpl(); break;
/* ORA (nn,Y) */
case 0x11: ora(load_byte(addr_indy()),5); break;
/* ORA nn,X */
case 0x15: ora(load_byte(addr_zerox()),4); break;
/* ASL nn,X */
case 0x16: asl_mem(addr_zerox(),6); break;
/* CLC */
case 0x18: clc(); break;
/* ORA nnnn,Y */
case 0x19: ora(load_byte(addr_absy()),4); break;
/* ORA nnnn,X */
case 0x1D: ora(load_byte(addr_absx()),4); break;
/* ASL nnnn,X */
case 0x1E: asl_mem(addr_absx(),7); break;
/* JSR */
case 0x20: jsr(); break;
/* AND (nn,X) */
case 0x21: _and(load_byte(addr_indx()),6); break;
/* BIT nn */
case 0x24: bit(addr_zero(),3); break;
/* AND nn */
case 0x25: _and(load_byte(addr_zero()),3); break;
/* ROL nn */
case 0x26: rol_mem(addr_zero(),5); break;
/* PLP */
case 0x28: plp(); break;
/* AND #nn */
case 0x29: _and(fetch_op(),2); break;
/* ROL A */
case 0x2A: rol_a(); break;
/* BIT nnnn */
case 0x2C: bit(addr_abs(),4); break;
/* AND nnnn */
case 0x2D: _and(load_byte(addr_abs()),4); break;
/* ROL nnnn */
case 0x2E: rol_mem(addr_abs(),6); break;
/* BMI nn */
case 0x30: bmi(); break;
/* AND (nn,Y) */
case 0x31: _and(load_byte(addr_indy()),5); break;
/* AND nn,X */
case 0x35: _and(load_byte(addr_zerox()),4); break;
/* ROL nn,X */
case 0x36: rol_mem(addr_zerox(),6); break;
/* SEC */
case 0x38: sec(); break;
/* AND nnnn,Y */
case 0x39: _and(load_byte(addr_absy()),4); break;
/* AND nnnn,X */
case 0x3D: _and(load_byte(addr_absx()),4); break;
/* ROL nnnn,X */
case 0x3E: rol_mem(addr_absx(),7); break;
/* RTI */
case 0x40: rti(); break;
/* EOR (nn,X) */
case 0x41: eor(load_byte(addr_indx()),6); break;
/* EOR nn */
case 0x45: eor(load_byte(addr_zero()),3); break;
/* LSR nn */
case 0x46: lsr_mem(addr_zero(),5); break;
/* PHA */
case 0x48: pha(); break;
/* EOR #nn */
case 0x49: eor(fetch_op(),2); break;
/* BVC */
case 0x50: bvc(); break;
/* JMP nnnn */
case 0x4C: jmp(); break;
/* EOR nnnn */
case 0x4D: eor(load_byte(addr_abs()),4); break;
/* LSR A */
case 0x4A: lsr_a(); break;
/* LSR nnnn */
case 0x4E: lsr_mem(addr_abs(),6); break;
/* EOR (nn,Y) */
case 0x51: eor(load_byte(addr_indy()),5); break;
/* EOR nn,X */
case 0x55: eor(load_byte(addr_zerox()),4); break;
/* LSR nn,X */
case 0x56: lsr_mem(addr_zerox(),6); break;
/* CLI */
case 0x58: cli(); break;
/* EOR nnnn,Y */
case 0x59: eor(load_byte(addr_absy()),4); break;
/* EOR nnnn,X */
case 0x5D: eor(load_byte(addr_absx()),4); break;
/* LSR nnnn,X */
case 0x5E: lsr_mem(addr_absx(),7); break;
/* RTS */
case 0x60: rts(); break;
/* ADC (nn,X) */
case 0x61: adc(load_byte(addr_indx()),6); break;
/* ADC nn */
case 0x65: adc(load_byte(addr_zero()),3); break;
/* ROR nn */
case 0x66: ror_mem(addr_zero(),5); break;
/* PLA */
case 0x68: pla(); break;
/* ADC #nn */
case 0x69: adc(fetch_op(),2); break;
/* ROR A */
case 0x6A: ror_a(); break;
/* JMP (nnnn) */
case 0x6C: jmp_ind(); break;
/* ADC nnnn */
case 0x6D: adc(load_byte(addr_abs()),4); break;
/* ROR nnnn */
case 0x6E: ror_mem(addr_abs(),6); break;
/* BVS */
case 0x70: bvs(); break;
/* ADC (nn,Y) */
case 0x71: adc(load_byte(addr_indy()),5); break;
/* ADC nn,X */
case 0x75: adc(load_byte(addr_zerox()),4); break;
/* ROR nn,X */
case 0x76: ror_mem(addr_zerox(),6); break;
/* SEI */
case 0x78: sei(); break;
/* ADC nnnn,Y */
case 0x79: adc(load_byte(addr_absy()),4); break;
/* ADC nnnn,X */
case 0x7D: adc(load_byte(addr_absx()),4); break;
/* ROR nnnn,X */
case 0x7E: ror_mem(addr_absx(),7); break;
/* STA (nn,X) */
case 0x81: sta(addr_indx(),6); break;
/* STY nn */
case 0x84: sty(addr_zero(),3); break;
/* STA nn */
case 0x85: sta(addr_zero(),3); break;
/* STX nn */
case 0x86: stx(addr_zero(),3); break;
/* DEY */
case 0x88: dey(); break;
/* TXA */
case 0x8A: txa(); break;
/* STY nnnn */
case 0x8C: sty(addr_abs(),4); break;
/* STA nnnn */
case 0x8D: sta(addr_abs(),4); break;
/* STX nnnn */
case 0x8E: stx(addr_abs(),4); break;
/* BCC nn */
case 0x90: bcc(); break;
/* STA (nn,Y) */
case 0x91: sta(addr_indy(),6); break;
/* STY nn,X */
case 0x94: sty(addr_zerox(),4); break;
/* STA nn,X */
case 0x95: sta(addr_zerox(),4); break;
/* STX nn,Y */
case 0x96: stx(addr_zeroy(),4); break;
/* TYA */
case 0x98: tya(); break;
/* STA nnnn,Y */
case 0x99: sta(addr_absy(),5); break;
/* TXS */
case 0x9A: txs(); break;
/* STA nnnn,X */
case 0x9D: sta(addr_absx(),5); break;
/* LDY #nn */
case 0xA0: ldy(fetch_op(),2); break;
/* LDA (nn,X) */
case 0xA1: lda(load_byte(addr_indx()),6); break;
/* LDX #nn */
case 0xA2: ldx(fetch_op(),2); break;
/* LDY nn */
case 0xA4: ldy(load_byte(addr_zero()),3); break;
/* LDA nn */
case 0xA5: lda(load_byte(addr_zero()),3); break;
/* LDX nn */
case 0xA6: ldx(load_byte(addr_zero()),3); break;
/* TAY */
case 0xA8: tay(); break;
/* LDA #nn */
case 0xA9: lda(fetch_op(),2); break;
/* TAX */
case 0xAA: tax(); break;
/* LDY nnnn */
case 0xAC: ldy(load_byte(addr_abs()),4); break;
/* LDA nnnn */
case 0xAD: lda(load_byte(addr_abs()),4); break;
/* LDX nnnn */
case 0xAE: ldx(load_byte(addr_abs()),4); break;
/* BCS nn */
case 0xB0: bcs(); break;
/* LDA (nn,Y) */
case 0xB1: lda(load_byte(addr_indy()),5); break;
/* LDY nn,X */
case 0xB4: ldy(load_byte(addr_zerox()),3); break;
/* LDA nn,X */
case 0xB5: lda(load_byte(addr_zerox()),3); break;
/* LDX nn,Y */
case 0xB6: ldx(load_byte(addr_zeroy()),3); break;
/* CLV */
case 0xB8: clv(); break;
/* LDA nnnn,Y */
case 0xB9: lda(load_byte(addr_absy()),4); break;
/* TSX */
case 0xBA: tsx(); break;
/* LDY nnnn,X */
case 0xBC: ldy(load_byte(addr_absx()),4); break;
/* LDA nnnn,X */
case 0xBD: lda(load_byte(addr_absx()),4); break;
/* LDX nnnn,Y */
case 0xBE: ldx(load_byte(addr_absy()),4); break;
/* CPY #nn */
case 0xC0: cpy(fetch_op(),2); break;
/* CMP (nn,X) */
case 0xC1: cmp(load_byte(addr_indx()),6); break;
/* CPY nn */
case 0xC4: cpy(load_byte(addr_zero()),3); break;
/* CMP nn */
case 0xC5: cmp(load_byte(addr_zero()),3); break;
/* DEC nn */
case 0xC6: dec(addr_zero(),5); break;
/* INY */
case 0xC8: iny(); break;
/* CMP #nn */
case 0xC9: cmp(fetch_op(),2); break;
/* DEX */
case 0xCA: dex(); break;
/* CPY nnnn */
case 0xCC: cpy(load_byte(addr_abs()),4); break;
/* CMP nnnn */
case 0xCD: cmp(load_byte(addr_abs()),4); break;
/* DEC nnnn */
case 0xCE: dec(addr_abs(),6); break;
/* BNE nn */
case 0xD0: bne(); break;
/* CMP (nn,Y) */
case 0xD1: cmp(load_byte(addr_indy()),5); break;
/* CMP nn,X */
case 0xD5: cmp(load_byte(addr_zerox()),4); break;
/* DEC nn,X */
case 0xD6: dec(addr_zerox(),6); break;
/* CLD */
case 0xD8: cld(); break;
/* CMP nnnn,Y */
case 0xD9: cmp(load_byte(addr_absy()),4); break;
/* CMP nnnn,X */
case 0xDD: cmp(load_byte(addr_absx()),4); break;
/* DEC nnnn,X */
case 0xDE: dec(addr_absx(),7); break;
/* CPX #nn */
case 0xE0: cpx(fetch_op(),2); break;
/* SBC (nn,X) */
case 0xE1: sbc(load_byte(addr_indx()),6); break;
/* CPX nn */
case 0xE4: cpx(load_byte(addr_zero()),3); break;
/* SBC nn */
case 0xE5: sbc(load_byte(addr_zero()),3); break;
/* INC nn */
case 0xE6: inc(addr_zero(),5); break;
/* INX */
case 0xE8: inx(); break;
/* SBC #nn */
case 0xE9: sbc(fetch_op(),2); break;
/* NOP */
case 0xEA: nop(); break;
/* CPX nnnn */
case 0xEC: cpx(load_byte(addr_abs()),4); break;
/* SBC nnnn */
case 0xED: sbc(load_byte(addr_abs()),4); break;
/* INC nnnn */
case 0xEE: inc(addr_abs(),6); break;
/* BEQ nn */
case 0xF0: beq(); break;
/* SBC (nn,Y) */
case 0xF1: sbc(load_byte(addr_indy()),5); break;
/* SBC nn,X */
case 0xF5: sbc(load_byte(addr_zerox()),4); break;
/* INC nn,X */
case 0xF6: inc(addr_zerox(),6); break;
/* SED */
case 0xF8: sed(); break;
/* SBC nnnn,Y */
case 0xF9: sbc(load_byte(addr_absy()),4); break;
/* SBC nnnn,X */
case 0xFD: sbc(load_byte(addr_absx()),4); break;
/* INC nnnn,X */
case 0xFE: inc(addr_absx(),7); break;
/* Unknown or illegal instruction */
default:
D("Unknown instruction: %X at %04x\n", insn,pc());
retval = false;
}
return retval;
}
