int minDistance(string word1, string word2) {
vector<vector<int>> DP(word1.size()+1, vector<int> (word2.size()+1, 0));
for(int i = 1; i<=word1.size(); i++) {
DP[i][0] = i;
}
for(int j = 1; j <= word2.size(); j++) {
DP[0][j] = j;
}
for(int i = 1; i<=word1.size(); i++) {
for(int j=1; j<=word2.size(); j++) {
if(word1[i-1] == word2[j-1]) {
DP[i][j] = DP[i-1][j-1];
}
else {
DP[i][j] = min(min(DP[i-1][j] + 1, DP[i][j-1] + 1), DP[i-1][j-1] + 1);
}
}
}
return DP[word1.size()][word2.size()];
}
/* returns 0 on success */
static inline int
__addip(struct ip_set *set,
ip_set_ip_t ip, unsigned char *ethernet, ip_set_ip_t *hash_ip)
{
struct ip_set_macipmap *map =
(struct ip_set_macipmap *) set->data;
struct ip_set_macip *table =
(struct ip_set_macip *) map->members;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
if (test_and_set_bit(IPSET_MACIP_ISSET,
&table[ip - map->first_ip].flags))
return -EEXIST;
*hash_ip = ip;
DP("%u.%u.%u.%u, %u.%u.%u.%u", HIPQUAD(ip), HIPQUAD(*hash_ip));
memcpy(&table[ip - map->first_ip].ethernet, ethernet, ETH_ALEN);
return 0;
}
static int setpool(
struct sock *sk,
int optval,
void *user,
unsigned int len
) {
struct ip_pool_request req;
DP("ip_pool:setpool: optval=%d, user=%p, len=%d\n", optval, user, len);
if (!capable(CAP_NET_ADMIN))
return -EPERM;
if (optval != SO_IP_POOL)
return -EBADF;
if (len != sizeof(req))
return -EINVAL;
if (copy_from_user(&req, user, sizeof(req)) != 0)
return -EFAULT;
printk("obsolete op - upgrade your ippool(8) utility.\n");
return -EINVAL;
}
void CSVPHostMountCB::FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile)
{
DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::FileOpenL(%S)"), &aName);
CSVPHostFileCB& file=(*((CSVPHostFileCB*)aFile));
TBuf<KMaxPath> name;
TUint driveNumber = Drive().DriveNumber();
CanonicalizePathname(aName, driveNumber, name);
TSVPHostFsFileOpenInfo info(driveNumber, name,aMode,anOpen);
TInt err = SVP_HOST_FS_DEVICE().FileOpen(info);
User::LeaveIfError(err);
file.SetHandle(info.iHandle);
file.SetSize(info.iSize);
file.SetAtt(info.iAtt&KEntryAttMaskSupported);
TTime tempTime=file.Modified();
fileTimeToTime(info.iModified, tempTime, info.iTimeType);
file.SetModified(tempTime);
}
wyToast* wyToast::make(const char* text, float duration) {
// create texture of default toast background
wyTexture2D* bgTex = wyTexture2D::makeRawPNG((const char*)_toast_bg_png, sizeof(_toast_bg_png) - 2);
wyNinePatchSprite* bg = wyNinePatchSprite::make(bgTex, wyr(DP(24), DP(24), 1, 1));
// create label as content
wyLabel* label = wyLabel::make(text, SP(12), BOLD);
label->setLineWidth(wyDevice::winWidth * 4 / 5);
// create toast and set default margin
wyToast* t = WYNEW wyToast(bg, label, duration);
t->setMargin(DP(15), DP(20), DP(20), DP(15));
t->m_useDefaultBg = true;
return (wyToast*)t->autoRelease();
}
static uchar i2c_select_device (uchar dev_addr, uchar read, int ten_bit)
{
unsigned int status, data, bits = 7;
int count = 0;
DP (puts ("i2c_select_device\n"));
/* Output slave address */
if (ten_bit) {
bits = 10;
}
data = (dev_addr << 1);
/* set the read bit */
data |= read;
GT_REG_WRITE (I2C_DATA, data);
/* assert the address */
RESET_REG_BITS (I2C_CONTROL, BIT3);
udelay (I2C_DELAY);
GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
count = 0;
while (((status & 0xff) != 0x40) && ((status & 0xff) != 0x18)) {
udelay (I2C_DELAY);
if (count > 20) {
GT_REG_WRITE (I2C_CONTROL, (0x1 << 4)); /*stop */
return (status);
}
GT_REG_READ (I2C_STATUS_BAUDE_RATE, &status);
count++;
}
if (bits == 10) {
printf ("10 bit I2C addressing not yet implemented\n");
return (0xff);
}
return (0);
}
/* anything but zero is failure */
uchar
i2c_write (uchar dev_addr, unsigned int offset, int alen, uchar * data,
int len)
{
uchar status = 0;
unsigned int i2cFreq = CONFIG_SYS_I2C_SPEED;
DP (puts ("i2c_write\n"));
i2c_init (i2cFreq, 0); /* set the i2c frequency */
status = i2c_start (); /* send a start bit */
if (status) {
#ifdef DEBUG_I2C
printf ("Transaction start failed: 0x%02x\n", status);
#endif
return status;
}
status = i2c_set_dev_offset (dev_addr, offset, 0, alen); /* send the slave address + offset */
if (status) {
#ifdef DEBUG_I2C
printf ("Failed to set slave address & offset: 0x%02x\n",
status);
#endif
return status;
}
status = i2c_write_byte (data, len); /* write the data */
if (status) {
#ifdef DEBUG_I2C
printf ("Data not written: 0x%02x\n", status);
#endif
return status;
}
/* issue a stop bit */
i2c_stop ();
return 0;
}
static inline __u32
hash_id_cidr(struct ip_set_nethash *map,
ip_set_ip_t ip,
unsigned char cidr,
ip_set_ip_t *hash_ip)
{
__u32 id;
u_int16_t i;
ip_set_ip_t *elem;
*hash_ip = pack(ip, cidr);
for (i = 0; i < map->probes; i++) {
id = jhash_ip(map, i, *hash_ip) % map->hashsize;
DP("hash key: %u", id);
elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
if (*elem == *hash_ip)
return id;
}
return UINT_MAX;
}
/* Add, del, test parser */
static ip_set_ip_t
adt_parser(unsigned cmd, const char *optarg, void *data)
{
struct ip_set_req_macipmap *mydata =
(struct ip_set_req_macipmap *) data;
char *saved = ipset_strdup(optarg);
char *ptr, *tmp = saved;
DP("macipmap: %p %p", optarg, data);
ptr = strsep(&tmp, ":%");
parse_ip(ptr, &mydata->ip);
if (tmp)
parse_mac(tmp, mydata->ethernet);
else
memset(mydata->ethernet, 0, ETH_ALEN);
free(saved);
return 1;
}
int run_com_general(const char *buffer) {
int scan_count;
scan_count = sscanf(buffer, PROC_STRING, PROC_SCANF_LIST);
if( scan_count != LIST_LEN) {
printk("eth proc bad format %x != %x\n", scan_count, LIST_LEN );
return 1;
}
#ifndef INCLUDE_MULTI_QUEUE
printk("\n Be carefull eth is compiled without MULTI Q!! \n");
#endif
switch(command){
case COM_SRQ:
DP(" Port %x: Got SRQ command Q %x and packet type is %x <bpdu/arp/tcp/udp> \n",port,q,packett);
run_com_srq();
break;
case COM_SQ:
DP(" Port %x: Got SQ command Q %x direction %x <Rx/Tx> mac %2x:%2x:%2x:%2x:%2x:%2x\n",port, q, direct,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
run_com_sq();
break;
#ifdef INCLUDE_MULTI_QUEUE
case COM_SRP:
DP(" Port %x: Got SRP command Q %x policy %x <Fixed/WRR> \n",port,q,policy);
run_com_srp();
break;
case COM_SRQW:
DP(" Port %x: Got SQRW command Q %x weight %x \n",port,q,weight);
run_com_srqw();
break;
case COM_STP:
DP("STP cmd - Unsupported: Port %x Q %x policy %x <WRR/FIXED> weight %x\n",port,q,policy,weight);
break;
#endif /* INCLUDE_MULTI_QUEUE */
case COM_STS:
DP(" Port %x: Got STS command status %x\n",port,status);
run_com_statis();
break;
default:
printk("eth proc unknown command.\n");
}
return 0;
}
int minCut(string s) {
int slen = s.length ();
if (slen < 2) return 0;
dp.resize (slen);
for (int i=0;i<slen;i++) dp[i].resize (0);
for (int i=0;i<slen;i++){
int low = i, high = i+1;
while (low>=0 && high<slen && s[low]==s[high]){
dp[high].push_back (low); low--, high++;
}
dp[i].push_back (i);
low = i-1, high = i + 1;
while (low>=0 && high<slen && s[low]==s[high])
dp[high].push_back (low),low--, high++;
}
f.resize (slen+1);
fill_n (f.begin(), slen+1, -1);
f[0] = 0;
return DP(slen) - 1;
}
void knh_HashMap__k(Ctx *ctx, knh_Hash_t *o, OutputStream *w, String *m)
{
size_t pos = 0, c = 0;
size_t max = (KNH_HASH_TABLESIZE / o->hashop->size) * DP(o)->tables_size;
knh_putc(ctx, w, '{');
while(pos < max) {
knh_hashentry_t *e = knh_hashentry_at((knh_Hash_t*)o, pos);
if(e != NULL) {
if(c > 0) {
knh_write_delim(ctx,w);
}
knh_format(ctx, w, METHODN__k, e->key, KNH_NULL);
knh_putc(ctx, w, ':');
knh_putc(ctx, w, ' ');
knh_format(ctx, w, METHODN__k, e->value, KNH_NULL);
c++;
}
pos++;
}
knh_putc(ctx, w, '}');
}
/* anything other than zero is failure, no device */
int i2c_probe (uchar chip)
{
/* We are just looking for an <ACK> back. */
/* To see if the device/chip is there */
#ifdef DEBUG_I2C
unsigned int i2c_status;
#endif
uchar status = 0;
unsigned int i2cFreq = CONFIG_SYS_I2C_SPEED;
DP (puts ("i2c_probe\n"));
i2c_init (i2cFreq, 0); /* set the i2c frequency */
status = i2c_start (); /* send a start bit */
if (status) {
#ifdef DEBUG_I2C
printf ("Transaction start failed: 0x%02x\n", status);
#endif
return (int) status;
}
status = i2c_set_dev_offset (chip, 0, 0, 0); /* send the slave address + no offset */
if (status) {
#ifdef DEBUG_I2C
printf ("Failed to set slave address: 0x%02x\n", status);
#endif
return (int) status;
}
#ifdef DEBUG_I2C
GT_REG_READ (I2C_STATUS_BAUDE_RATE, &i2c_status);
printf ("address %#x returned %#x\n", chip, i2c_status);
#endif
/* issue a stop bit */
i2c_stop ();
return 0; /* successful completion */
}
// Create a new HTML file with a given filename and title
// The heading, if not given, will be the same as the title
void
html_head(FILE *of, const string fname, const string title, const char *heading)
{
swill_title(title.c_str());
if (DP())
cerr << "Write to " << fname << endl;
fprintf(of,
"<!doctype html public \"-//IETF//DTD HTML//EN\">\n"
"<html>\n"
"<head>\n"
"<meta name=\"GENERATOR\" content=\"CScout %s - %s\">\n",
Version::get_revision().c_str(),
Version::get_date().c_str());
fputs(
"<meta http-equiv=\"Content-Style-Type\" content=\"text/css\">"
"<style type=\"text/css\" >"
"<!--\n", of);
ifstream in;
string css_fname;
if (cscout_input_file("style.css", in, css_fname)) {
int val;
while ((val = in.get()) != EOF)
putc(val, of);
} else
fputs(
#include "css.c"
, of);
fputs(
"-->"
"</style>"
"</head>", of);
fprintf(of,
"<title>%s</title>\n"
"</head>\n"
"<body>\n"
"<h1>%s</h1>\n",
title.c_str(),
heading ? heading : title.c_str());
}
int i2c_write(uchar chip, uint addr, int alen, uchar *buffer, int len)
{
MV_TWSI_SLAVE twsiSlave;
DP(puts("i2c_write\n"));
twsiSlave.slaveAddr.type = ADDR7_BIT;
twsiSlave.slaveAddr.address = chip;
if(alen != 0){
twsiSlave.validOffset = MV_TRUE;
twsiSlave.offset = addr;
if(alen == 2)
{
twsiSlave.moreThen256 = MV_TRUE;
}
else
{
twsiSlave.moreThen256 = MV_FALSE;
}
}
i2c_init(CONFIG_SYS_I2C_SPEED,0); /* set the i2c frequency */
return mvTwsiWrite (i2c_current_bus, &twsiSlave, buffer, len);
}
static
knh_dbcur_t *knh_dbquery__sqlite3(Ctx *ctx, knh_db_t *hdr, knh_bytes_t sql, ResultSet *rs)
{
if(rs == NULL) {
int r = sqlite3_exec((sqlite3*)hdr, (const char*)sql.buf, NULL, NULL, NULL);
if(r != SQLITE_OK) {
knh_sqlite3_perror(ctx, (sqlite3*)hdr, r);
}
return NULL;
}
else {
sqlite3_stmt *stmt = NULL;
sqlite3_prepare((sqlite3*)hdr, (char*)sql.buf, sql.len, &stmt, NULL);
// if (r != SQLITE_OK) {
// sqlite3_finalize(stmt);
// DBG2_P("msg='%s', sqlite3_errmsg((sqlite3)hdr));
// return NULL;
// }
// r = sqlite3_reset(stmt);
// if(r != SQLITE_OK) {
// sqlite3_finalize(stmt);
// return NULL;
// }
size_t column_size = (size_t)sqlite3_column_count(stmt);
//DBG2_P("column_size=%d", column_size);
knh_ResultSet_initColumn(ctx, rs, column_size);
if(column_size > 0) {
size_t i;
for(i = 0; i < DP(rs)->column_size; i++) {
char *n = (char*)sqlite3_column_name(stmt, i);
//DBG2_P("(%d) name = '%s'", i, n);
if(n != NULL) {
knh_ResultSet_setName(ctx, rs, i, new_String(ctx, B(n), NULL));
}
}
}
return (knh_dbcur_t*)stmt;
}
}
static knh_String_t *Gamma_vperror(CTX ctx, int pe, const char *fmt, va_list ap)
{
knh_String_t *msg = TS_EMPTY;
int isPRINT = (pe <= KC_DWARN) ? 1 : 0;
if(pe != KC_DEBUG && (CTX_isInteractive(ctx) || knh_isCompileOnly(ctx))) {
isPRINT = 1;
}
if(Gamma_isQuiet(ctx->gma) || ctx->gma->uline == 0) {
isPRINT = 0;
}
//DBG_P("/*isPRINT=%d*/ uline=%d", isPRINT, ctx->gma->uline);
if(isPRINT == 1) {
knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf);
knh_write_uline(ctx, cwb->w, ctx->gma->uline);
knh_write_ascii(ctx, cwb->w, KC__(pe));
knh_vprintf(ctx, cwb->w, fmt, ap);
msg = knh_cwb_newString(ctx, cwb);
knh_Array_add(ctx, DP(ctx->gma)->errmsgs, msg);
fprintf(stderr, "%s - %s%s\n", TERM_BNOTE(ctx, pe), S_tochar(msg), TERM_ENOTE(ctx, pe));
}
return msg;
}
int bnx2x_vfpf_release(struct bnx2x *bp)
{
struct vfpf_release_tlv *req = &bp->vf2pf_mbox->req.release;
struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
u32 rc = 0, vf_id;
/* clear mailbox and prep first tlv */
bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_RELEASE, sizeof(*req));
if (bnx2x_get_vf_id(bp, &vf_id))
return -EAGAIN;
req->vf_id = vf_id;
/* add list termination tlv */
bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
sizeof(struct channel_list_end_tlv));
/* output tlvs list */
bnx2x_dp_tlv_list(bp, req);
/* send release request */
rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
if (rc)
/* PF timeout */
return rc;
if (resp->hdr.status == PFVF_STATUS_SUCCESS) {
/* PF released us */
DP(BNX2X_MSG_SP, "vf released\n");
} else {
/* PF reports error */
BNX2X_ERR("PF failed our release request - are we out of sync? response status: %d\n",
resp->hdr.status);
return -EAGAIN;
}
return 0;
}
/**
* @param A: an integer array.
* @param k: a positive integer (k <= length(A))
* @param target: a integer
* @return an integer
*/
int kSum2(vector<int> A, int k, int target) {
int n = A.size();
// DP[i][j][t] means the total number of combinations that j numbers out of first A[0~i-1] sum up to t
vector<vector<vector<int> > > DP(n+1, vector<vector<int> >(k+1, vector<int>(target+1, 0)));
for (int i = 0; i <= A.size(); i++) {
DP[i][0][0] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(k,i); j++) {
for (int t = 1; t < A[i-1]; t++) {
DP[i][j][t] = DP[i-1][j][t];
}
for (int t = A[i-1]; t <= target; t++) {
DP[i][j][t] = DP[i-1][j][t] + DP[i-1][j-1][t-A[i-1]];
}
}
}
return DP[n][k][target];
}
STDMETHODIMP CGfxFB::Open(DWORD dwWidth, DWORD dwHeight, DWORD dwBuffers,
const DWORD *pdwFourCC, IMcPreInit* pPrepareData, RECT* pDst)
{
POINT pt;
if(dwWidth==0 || dwHeight==0)
return E_FAIL;
m_dwWidth = dwWidth;
m_dwHeight = dwHeight;
if(pdwFourCC)
m_pdwFourCCList = pdwFourCC;
else
m_pdwFourCCList = const_dwFourCC;
DP("[GFXFB]Open w:%d h:%d \n",m_dwWidth, m_dwHeight);
pt.x = m_rectDst.left;
pt.y = m_rectDst.top;
m_bScnClip = TRUE;
return CreateSurfaces(dwBuffers);
}
void knh_Stmt__s(Ctx *ctx, Stmt *o, OutputStream *w, String *m)
{
knh_intptr_t i;
knh_putc(ctx, w, '(');
if(SP(o)->stt != STT_OP && SP(o)->stt != STT_NEW && SP(o)->stt != STT_CALL ) {
knh_write_char(ctx, w, knh_stmt_tochar(SP(o)->stt));
if(DP(o)->size > 0) {
knh_putc(ctx, w, ' ');
}
}
for(i = 0; i < DP(o)->size; i++) {
if(i > 0) knh_putc(ctx, w, ' ');
if(IS_Token(DP(o)->terms[i])) {
knh_Token__s(ctx, DP(o)->tokens[i], w, m);
} else {
KNH_ASSERT(IS_Stmt(DP(o)->terms[i]));
knh_Stmt__s(ctx, DP(o)->stmts[i], w, m);
if(IS_NOTNULL(DP(DP(o)->stmts[i])->next)) {
knh_write_dots(ctx, w);
}
}
}
knh_putc(ctx, w, ')');
}
/* Tell PF about SB addresses */
int bnx2x_vfpf_init(struct bnx2x *bp)
{
struct vfpf_init_tlv *req = &bp->vf2pf_mbox->req.init;
struct pfvf_general_resp_tlv *resp = &bp->vf2pf_mbox->resp.general_resp;
int rc, i;
/* clear mailbox and prep first tlv */
bnx2x_vfpf_prep(bp, &req->first_tlv, CHANNEL_TLV_INIT, sizeof(*req));
/* status blocks */
for_each_eth_queue(bp, i)
req->sb_addr[i] = (dma_addr_t)bnx2x_fp(bp, i,
status_blk_mapping);
/* statistics - requests only supports single queue for now */
req->stats_addr = bp->fw_stats_data_mapping +
offsetof(struct bnx2x_fw_stats_data, queue_stats);
/* add list termination tlv */
bnx2x_add_tlv(bp, req, req->first_tlv.tl.length, CHANNEL_TLV_LIST_END,
sizeof(struct channel_list_end_tlv));
/* output tlvs list */
bnx2x_dp_tlv_list(bp, req);
rc = bnx2x_send_msg2pf(bp, &resp->hdr.status, bp->vf2pf_mbox_mapping);
if (rc)
return rc;
if (resp->hdr.status != PFVF_STATUS_SUCCESS) {
BNX2X_ERR("INIT VF failed: %d. Breaking...\n",
resp->hdr.status);
return -EAGAIN;
}
DP(BNX2X_MSG_SP, "INIT VF Succeeded\n");
return 0;
}
int numDecodings(string s) {
if(s.empty())return 0;
if(s.size()==1 && s[0]=='0') return 0;
vector<int>DP(s.size()+1,1);
for(int i=2; i<=s.size();i++){
int cur = s[i-1] - '0';
int pre = s[i-2] - '0';
if((pre==0 && i==2) || (cur==0 && (pre>2 || pre==0)))
return 0;
if( (pre==2 && cur<=6 && cur>0) || (pre==1 && cur<=9 && cur>0) ) {
if(i<s.size() && s[i]=='0'){
DP[i] = DP[i-1];
}else
DP[i] = DP[i-1] + DP[i-2];
}
else{
DP[i] = DP[i-1];
}
}
return DP[s.size()];
}
int run_com_general(const char *buffer) {
int scan_count;
scan_count = sscanf(buffer, PROC_STRING, PROC_SCANF_LIST);
if( scan_count != LIST_LEN) {
printk("eth proc bad format %x != %x\n", scan_count, LIST_LEN );
return 1;
}
switch(command){
case COM_SRQ:
DP(" Port %x: Got SRQ command Q %x and packet type is %x <bpdu/arp/tcp/udp> \n",port,q,packet);
run_com_srq();
break;
case COM_SQ:
DP(" Port %x: Got SQ command Q %x mac %2x:%2x:%2x:%2x:%2x:%2x\n",port, q,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
run_com_sq();
break;
#if (MV_ETH_RX_Q_NUM > 1)
case COM_SRP:
DP(" Port %x: Got SRP command Q %x policy %x <Fixed/WRR> \n",port,q,policy);
printk("Not supported\n");
break;
case COM_SRQW:
DP(" Port %x: Got SQRW command Q %x weight %x \n",port,q,weight);
printk("Not supported\n");
break;
case COM_STP:
DP("STP cmd - Unsupported: Port %x Q %x policy %x <WRR/FIXED> weight %x\n",port,q,policy,weight);
break;
#endif /* MV_ETH_RX_Q_NUM > 1 */
case COM_STS:
DP(" Port %x: Got STS command status %x\n",port,status);
run_com_stats();
break;
default:
printk("eth proc unknown command.\n");
}
return 0;
}
/*******************************************************************************
概要 ： アプリケーション・メモリ構造情報クラスの初期化
説明 ：
Include ： AMSI.h
引数 ： const AppliHeader& CR_AplHead アプリケーション情報
戻り値 ： void
*******************************************************************************/
void AMSI::Init( const AppliHeader& CR_AplHead )
{
//スタックサイズ修正
if( CR_AplHead.u4_StackSize < STACK_MIN_SIZE )
Mui_StackSize = STACK_MIN_SIZE;
else if( CR_AplHead.u4_StackSize > STACK_MAX_SIZE )
Mui_StackSize = STACK_MAX_SIZE;
else
Mui_StackSize = CR_AplHead.u4_StackSize;
Mui_StackSize = INT_CEIL_BIN( Mui_StackSize, 0xfff );
//ヒープサイズ修正
if( CR_AplHead.u4_HeapSize < HEAP_MIN_SIZE )
Mui_HeapSize = STACK_MIN_SIZE;
else if( CR_AplHead.u4_HeapSize > HEAP_MAX_SIZE )
Mui_HeapSize = STACK_MAX_SIZE;
else
Mui_HeapSize = CR_AplHead.u4_HeapSize;
Mui_HeapSize = INT_CEIL_BIN( Mui_HeapSize, 0xfff );
Mui_BodySize = INT_CEIL_BIN( CR_AplHead.u4_AppliSize - sizeof (AppliHeader), 0xfff );
DP( "Mui_BodySize:%#x", Mui_BodySize );
}
METHOD knh__System_setMethodCompilationListener(Ctx *ctx, knh_sfp_t *sfp)
{
String *key;
if(IS_NULL(sfp[2].s)) {
key = T__("MethodC");
}
else {
knh_cwb_t cwbbuf, *cwb = knh_cwb_openinit(ctx, &cwbbuf, STEXT("MethodC"));
knh_bytes_t anno = knh_String_tobytes(sfp[2].s);
if(anno.buf[0] != '@') {
knh_cwb_putc(ctx, cwb, '@');
}
knh_cwb_write(ctx, cwb, anno);
key = knh_cwb_newString(ctx, cwb);
}
KNH_LOCK(ctx, LOCK_SYSTBL, NULL);
{
DictMap *dm = DP(ctx->sys)->listenerDictMap;
knh_DictMap_set(ctx, dm, key, sfp[1].o);
}
KNH_UNLOCK(ctx, LOCK_SYSTBL, NULL);
KNH_RETURN_void(ctx, sfp);
}
void knh_throw(Ctx *ctx, knh_sfp_t *sfp, long start)
{
if(IS_Exception(ctx->e)) {
knh_sfp_t *sp = (sfp == NULL) ? ctx->esp : sfp + start;
while(ctx->stack <= sp) {
DBG_P("[%d] cid=%s ivalue=%lld", (sp - ctx->stack), CLASS__(knh_Object_cid(sp[0].o)), sp[0].ivalue);
if(sp[0].callmtd != NULL && isCalledMethod(ctx, sp)) {
sp = knh_Exception_addStackTrace(ctx, ctx->e, sp+1);
}
if(IS_ExceptionHandler(sp[0].hdr) && DP(sp[0].hdr)->return_address != NULL) {
knh_ExceptionHandler_longjmp(ctx, sp[0].hdr);
goto L_NOCATCH;
}
sp--;
}
L_NOCATCH:;
{
knh_Method_t *mtdf = knh_getSystemFormatter(ctx, CLASS_Exception, MN__dump);
knh_write_Object(ctx, KNH_STDERR, sfp, &mtdf, UPCAST(ctx->e));
}
knh_exit(ctx, 0);
}
}
const string
Token::get_refactored_name() const
{
if (parts.begin() == parts.end())
return val;
string result;
for (dequeTpart::const_iterator i = parts.begin(); i != parts.end(); i++) {
Eclass *ec = i->get_tokid().check_ec();
if (ec == NULL)
return val;
IdProp::const_iterator idi;
idi = Identifier::ids.find(ec);
if (idi == Identifier::ids.end())
return val;
if (idi->second.get_replaced())
result += idi->second.get_newid();
else
result += idi->second.get_id();
}
if (DP())
cout << "refactored name for " << val << " is " << result << endl;
return result;
}
/* Final check; exit if not ok. */
static void
create_final(void *data, unsigned int flags)
{
struct ip_set_req_macipmap_create *mydata =
(struct ip_set_req_macipmap_create *) data;
if (flags == 0)
exit_error(PARAMETER_PROBLEM,
"Need to specify --from and --to, or --network\n");
if (flags & OPT_CREATE_NETWORK) {
/* --network */
if ((flags & OPT_CREATE_FROM) || (flags & OPT_CREATE_TO))
exit_error(PARAMETER_PROBLEM,
"Can't specify --from or --to with --network\n");
} else {
/* --from --to */
if ((flags & OPT_CREATE_FROM) == 0
|| (flags & OPT_CREATE_TO) == 0)
exit_error(PARAMETER_PROBLEM,
"Need to specify both --from and --to\n");
}
DP("from : %x to: %x diff: %d match unset: %d", mydata->from,
mydata->to, mydata->to - mydata->from,
flags & OPT_CREATE_MATCHUNSET);
if (mydata->from > mydata->to)
exit_error(PARAMETER_PROBLEM,
"From can't be lower than to.\n");
if (mydata->to - mydata->from > MAX_RANGE)
exit_error(PARAMETER_PROBLEM,
"Range too large. Max is %d IPs in range\n",
MAX_RANGE+1);
}
/*
* Thread start routine that repeatedly locks a mutex and
* increments a counter.
*/
PRIVATE void *counter_thread()
{
S32 status;
U32 spin;
/*
* Until end_time, increment the counter each
* second. Instead of just incrementing the counter, it
* sleeps for another second with the mutex locked, to give
* monitor_thread a reasonable chance of running.
*/
while (time(NULL) < end_time)
{
status = pthread_mutex_lock (&mutex);
if (status != 0)
{
err_abort (status, "Lock mutex");
}
for (spin = 0; spin < SPIN; spin++)
{
counter++;
}
status = pthread_mutex_unlock (&mutex);
if (status != 0)
{
err_abort (status, "Unlock mutex");
}
sleep (1);
}
DP("Counter is %d\n", counter);
return NULL;
}
