P op_mapwindow(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
P k;
if (dvtdisplay == NULL) return NO_XWINDOWS;
if (o_2 < FLOORopds) return OPDS_UNF;
if (CLASS(o_1) != BOOL) return OPD_CLA;
switch (CLASS(o_2)) {
case NULLOBJ:
for (k = 0; k < ndvtwindows; k++)
if (BOOL_VAL(o_1)) mapraisewindow(dvtwindows[k]);
else HXUnmapWindow(dvtdisplay, dvtwindows[k]);
break;
case NUM:
if (!PVALUE(o_2,&wid)) return UNDF_VAL;
for (k = 0; k < ndvtwindows && dvtwindows[k] != wid; k++);
if (k == ndvtwindows) break;
if (BOOL_VAL(o_1)) mapraisewindow(wid);
else HXUnmapWindow(dvtdisplay,wid);
break;
default:
return OPD_CLA;
};
FREEopds = o_2;
return OK;
#endif
}
/*------------------------------------------------ topwindow
*
* window# true | --
*
* make window float above other iff true
*/
P op_makewindowtop(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
P k;
XEvent event;
if (dvtdisplay == NULL) return NO_XWINDOWS;
if (o_2 < FLOORopds) return OPDS_UNF;
if (CLASS(o_1) != BOOL || CLASS(o_2) != NUM) return OPD_CLA;
if (!PVALUE(o_2, &wid)) return UNDF_VAL;
FREEopds = o_2;
for (k = 0; k < ndvtwindows && dvtwindows[k] != wid; k++);
if (k == ndvtwindows) return OK;
event.xclient.type = ClientMessage;
event.xclient.display = dvtdisplay;
event.xclient.window = wid;
event.xclient.message_type
= HXInternAtom(dvtdisplay, "_NET_WM_STATE", False);
event.xclient.format = 32;
event.xclient.data.l[0] = (BOOL_VAL(o2) ? 1 : 0);
event.xclient.data.l[1]
= HXInternAtom(dvtdisplay, "_NET_WM_STATE_ABOVE", False);
event.xclient.data.l[2] = 0;
event.xclient.data.l[3] = 2;
event.xclient.data.l[4] = 0;
HXSendEvent(dvtdisplay, XRootWindowOfScreen(dvtscreen),
False, (SubstructureNotifyMask|SubstructureRedirectMask),
&event);
return OK;
#endif
}
// n k | (n/k)
DM_INLINE_STATIC P combinations(void) {
P n, k, i, j;
if (o_2 < FLOORopds) return OPDS_UNF;
if (CLASS(o_1) != NUM) return OPD_CLA;
if (CLASS(o_2) != NUM) return OPD_CLA;
if (! PVALUE(o_2, &n)) return UNDF_VAL;
if (! PVALUE(o_1, &k)) return UNDF_VAL;
if (n < 0 || k < 0 || n < k) return RNG_CHK;
if (n > max_kn) return RNG_CHK;
TAG(o_2) = (NUM | DOUBLETYPE);
ATTR(o_2) = 0;
FREEopds = o_1;
if (n == k || k == 0) {
*(D*) NUM_VAL(o_1) = 1;
return OK;
}
if (n <= max_n) {
*(D*) NUM_VAL(o_1) = binom[n][k];
return OK;
}
for (i = max_n+1; i <= n; ++i) {
binom[i][0] = binom[i][i] = 1;
for (j = 1; j < i; ++j) {
binom[i][j] = binom[i-1][j-1] + binom[i-1][j];
}
}
max_n = n;
*(D*) NUM_VAL(o_1) = binom[n][k];
return OK;
}
P op_resizewindow(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
P width, height;
P k;
if (dvtdisplay == NULL) return NO_XWINDOWS;
if (o_3 < FLOORopds) return OPDS_UNF;
if (CLASS(o_3) != NUM) return OPD_CLA;
if (!PVALUE(o_3,&wid)) return UNDF_VAL;
if (CLASS(o_2) != NUM) return OPD_CLA;
if (!PVALUE(o_2,&width)) return UNDF_VAL;
if (CLASS(o_1) != NUM) return OPD_CLA;
if (!PVALUE(o_1,&height)) return UNDF_VAL;
for (k = 0; k < ndvtwindows; k++)
if (dvtwindows[k] == wid) {
resizewindow(width, height);
break;
}
FREEopds = o_3;
return OK;
#endif
}
static GstMPEGStream *
gst_mpeg_demux_get_private_stream (GstMPEGDemux * mpeg_demux,
guint8 stream_nr, gint type, const gpointer info)
{
GstMPEGStream *str;
gchar *name;
g_return_val_if_fail (stream_nr < GST_MPEG_DEMUX_NUM_PRIVATE_STREAMS, NULL);
str = mpeg_demux->private_stream[stream_nr];
if (str == NULL) {
name = g_strdup_printf ("private_%d", stream_nr + 1);
str = g_new0 (GstMPEGStream, 1);
CLASS (mpeg_demux)->init_stream (mpeg_demux, type, str, stream_nr, name,
CLASS (mpeg_demux)->private_template);
g_free (name);
gst_pad_set_active (str->pad, TRUE);
gst_element_add_pad (GST_ELEMENT (mpeg_demux), str->pad);
mpeg_demux->private_stream[stream_nr] = str;
}
return str;
}
P op_errormessage(void)
{
LBIG e, pid, port;
P nb, tnb;
B *m, *s;
if (o_6 < FLOORopds) goto baderror;
if (CLASS(o_6) != NUM) goto baderror;
if (! VALUE(o_6, &pid)) goto baderror;
if (TAG(o_5) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_4) != NUM) goto baderror;
if (! VALUE(o_4, &port)) goto baderror;
if (TAG(o_3) != (ARRAY | BYTETYPE)) goto baderror;
if (CLASS(o_2) != NUM) goto baderror;
if (!VALUE(o_2, &e)) goto baderror;
if (TAG(o_1) != (ARRAY | BYTETYPE)) goto baderror;
s = (B *)VALUE_BASE(o_1);
tnb = ARRAY_SIZE(o_1);
nb = dm_snprintf((char*) s, tnb, "On %*s port %llu, pid %llu: ",
(int) ARRAY_SIZE(o_5),
(char*) VALUE_BASE(o_5),
(unsigned long long) port,
(unsigned long long) pid);
s += nb;
tnb -= nb;
if ((P)e < 0) /*Clib error */
nb = dm_snprintf((char*) s, tnb, "errno: %s",
(char*) strerror(-(int)e));
else { /* one of our error codes: decode */
m = geterror((P) e);
nb = strlen((char*) m);
if (nb > tnb) nb = tnb;
moveB(m, s, nb);
}
s += nb;
tnb -= nb;
nb = dm_snprintf((char*)s, tnb, " in %*s\n",
(int) ARRAY_SIZE(o_3),
(char*) VALUE_BASE(o_3));
ARRAY_SIZE(o_1) = (P)(s + nb) - VALUE_BASE(o_1);
moveframe(o_1,o_6);
FREEopds = o_5;
return OK;
baderror:
printf("**Error with corrupted error info on operand stack!\n");
return op_halt();
}
/*
* Method: Pm_HasHostError
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1HasHostError
(JNIEnv *env, jclass cl, jobject jstream)
{
CLASS(c, jstream);
ADDRESS_FID(fid, c);
return Pm_HasHostError(PMSTREAM(jstream, fid));
}
/*
* Method: Pm_WriteShort
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1WriteShort
(JNIEnv *env, jclass cl, jobject jstream, jint when, jint msg)
{
CLASS(c, jstream);
ADDRESS_FID(fid, c);
return Pm_WriteShort(PMSTREAM(jstream, fid), when, msg);
}
/*
* Method: Pm_SetChannelMask
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1SetChannelMask
(JNIEnv *env, jclass cl, jobject jstream, jint mask)
{
CLASS(c, jstream);
ADDRESS_FID(fid, c);
return Pm_SetChannelMask(PMSTREAM(jstream, fid), mask);
}
static P copy_list(B *sf, B **df, B **freevm)
{
B *f, *cf;
P k, n;
f = (B *)*freevm;
n = (LIST_CEIL(sf) - VALUE_BASE(sf)) / FRAMEBYTES;
if ((*freevm += FRAMEBYTES + n * VALUEBYTES(WORDTYPE)) > CEILvm)
return VM_OVF;
TAG(f) = ARRAY | WORDTYPE;
ATTR(f) = 0;
VALUE_BASE(f) = (P)f + FRAMEBYTES;
ARRAY_SIZE(f) = 1;
cf = (B *)VALUE_BASE(sf);
k = n;
while (k) {
if (CLASS(cf) != NUM) return OPD_CLA;
MOVE(cf,f);
VALUE_BASE(f) += VALUEBYTES(WORDTYPE);
cf += FRAMEBYTES; k--;
}
VALUE_BASE(f) = (P)f + FRAMEBYTES;
ARRAY_SIZE(f) = n;
*df = f;
return OK;
}
P op_fillrectangle(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
B *xyf, *freevm;
P retc, k;
if (dvtdisplay == NULL) return NO_XWINDOWS;
freevm = FREEvm;
if ((retc = coloropd()) != OK) return retc;
if ((retc = xy(&xyf,&freevm)) != OK) return retc;
if (ARRAY_SIZE(xyf) != 4) return RNG_CHK;
if (o_1 < FLOORopds) return (OPDS_UNF);
if (CLASS(o_1) != NUM) return OPD_CLA;
if (!PVALUE(o_1,&wid)) return UNDF_VAL;
FREEopds = o_1;
for (k = 0; k < ndvtwindows; k++)
if (dvtwindows[k] == wid) break;
if (k >= ndvtwindows) return OK;
HXFillRectangles(dvtdisplay,wid,dvtgc,(XRectangle *)VALUE_BASE(xyf),1);
return OK;
#endif
}
char*
v4parseip(uint8_t *to, char *from)
{
int i;
char *p;
p = from;
for(i = 0; i < 4 && *p; i++){
to[i] = strtoul(p, &p, 0);
if(*p == '.')
p++;
}
switch(CLASS(to)){
case 0: /* class A - 1 uchar net */
case 1:
if(i == 3){
to[3] = to[2];
to[2] = to[1];
to[1] = 0;
} else if (i == 2){
to[3] = to[1];
to[1] = 0;
}
break;
case 2: /* class B - 2 uchar net */
if(i == 3){
to[3] = to[2];
to[2] = 0;
}
break;
}
return p;
}
static Res amstSegInit(Seg seg, Pool pool, Addr base, Size size, ArgList args)
{
AMSTSeg amstseg;
AMST amst;
Res res;
/* Initialize the superclass fields first via next-method call */
res = NextMethod(Seg, AMSTSeg, init)(seg, pool, base, size, args);
if (res != ResOK)
return res;
amstseg = CouldBeA(AMSTSeg, seg);
AVERT(Pool, pool);
amst = PoolAMST(pool);
AVERT(AMST, amst);
/* no useful checks for base and size */
amstseg->next = NULL;
amstseg->prev = NULL;
SetClassOfPoly(seg, CLASS(AMSTSeg));
amstseg->sig = AMSTSegSig;
AVERC(AMSTSeg, amstseg);
return ResOK;
}
static Res AMSTInit(Pool pool, Arena arena, PoolClass klass, ArgList args)
{
AMST amst;
AMS ams;
Res res;
res = NextMethod(Pool, AMSTPool, init)(pool, arena, klass, args);
if (res != ResOK)
return res;
amst = CouldBeA(AMSTPool, pool);
ams = MustBeA(AMSPool, pool);
ams->segSize = AMSTSegSizePolicy;
ams->segClass = AMSTSegClassGet;
amst->failSegs = TRUE;
amst->splits = 0;
amst->merges = 0;
amst->badSplits = 0;
amst->badMerges = 0;
amst->bsplits = 0;
amst->bmerges = 0;
SetClassOfPoly(pool, CLASS(AMSTPool));
amst->sig = AMSTSig;
AVERC(AMSTPool, amst);
return ResOK;
}
static Res NInit(Pool pool, Arena arena, PoolClass klass, ArgList args)
{
PoolN poolN;
Res res;
AVER(pool != NULL);
AVERT(Arena, arena);
AVERT(ArgList, args);
UNUSED(klass); /* used for debug pools only */
res = NextMethod(Pool, NPool, init)(pool, arena, klass, args);
if (res != ResOK)
goto failNextInit;
poolN = CouldBeA(NPool, pool);
/* Initialize pool-specific structures. */
SetClassOfPoly(pool, CLASS(NPool));
AVERC(PoolN, poolN);
return ResOK;
failNextInit:
AVER(res != ResOK);
return res;
}
P op_drawline(void)
{
#if X_DISPLAY_MISSING
return NO_XWINDOWS;
#else
B *xyf, *freevm;
P retc, k;
if (dvtdisplay == NULL) return NO_XWINDOWS;
if (o_1 < FLOORopds) return OPDS_UNF;
freevm = FREEvm;
if ((retc = coloropd()) != OK) return retc;
if ((retc = xy(&xyf,&freevm)) != OK) return retc;
if (ARRAY_SIZE(xyf) < 4) return RNG_CHK;
if (o_1 < FLOORopds) return (OPDS_UNF);
if (CLASS(o_1) != NUM) return OPD_CLA;
if (!PVALUE(o_1,&wid)) return UNDF_VAL;
FREEopds = o_1;
for (k = 0; k < ndvtwindows; k++)
if (dvtwindows[k] == wid) break;
if (k >= ndvtwindows) return OK;
HXDrawLines(dvtdisplay,wid,dvtgc,(XPoint *)VALUE_BASE(xyf),
ARRAY_SIZE(xyf)>>1, CoordModeOrigin);
return OK;
#endif
}
static Res rankBufInit(Buffer buffer, Pool pool, Bool isMutator, ArgList args)
{
Rank rank = BUFFER_RANK_DEFAULT;
Res res;
ArgStruct arg;
AVERT(ArgList, args);
if (ArgPick(&arg, args, MPS_KEY_RANK))
rank = arg.val.rank;
AVERT(Rank, rank);
/* Initialize the superclass fields first via next-method call */
res = NextMethod(Buffer, RankBuf, init)(buffer, pool, isMutator, args);
if (res != ResOK)
return res;
BufferSetRankSet(buffer, RankSetSingle(rank));
SetClassOfPoly(buffer, CLASS(RankBuf));
AVERC(RankBuf, buffer);
EVENT4(BufferInitRank, buffer, pool, BOOLOF(buffer->isMutator), rank);
return ResOK;
}
// x l | Pl(x)
DM_INLINE_STATIC P legendre(void) {
P l, i;
D x, Px, Px_1, Px_2;
if (o_2 < FLOORopds) return OPDS_UNF;
if (CLASS(o_1) != NUM) return OPD_CLA;
if (! PVALUE(o_1, &l)) return UNDF_VAL;
if (l < 0) return RNG_CHK;
if (TAG(o_2) != (NUM | DOUBLETYPE)) return OPD_TYP;
FREEopds = o_1;
if (l == 0) {
*(D*) NUM_VAL(o_1) = 1;
return OK;
}
Px = x = *(D*) NUM_VAL(o_1);
Px_1 = 1;
for (i = 2; i <= l; ++i) {
Px_2 = Px_1;
Px_1 = Px;
Px = ((D)(2*i-1))/i*x*Px_1 - ((D)(i-1))/i*Px_2;
}
*(D*) NUM_VAL(o_1) = Px;
return OK;
}
/*
* Method: Pm_SetFilter
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1SetFilter
(JNIEnv *env, jclass cl, jobject jstream, jint filters)
{
CLASS(c, jstream);
ADDRESS_FID(fid, c);
return Pm_SetFilter(PMSTREAM(jstream, fid), filters);
}
unsigned long
parseip(char *to, char *from)
{
int i;
char *p;
p = from;
memset(to, 0, 4);
for(i = 0; i < 4 && *p; i++) {
to[i] = strtoul(p, &p, 0);
if(*p == '.')
p++;
}
switch(CLASS(to)) {
case 0: /* class A - 1 byte net */
case 1:
if(i == 3) {
to[3] = to[2];
to[2] = to[1];
to[1] = 0;
} else if (i == 2) {
to[3] = to[1];
to[1] = 0;
}
break;
case 2: /* class B - 2 byte net */
if(i == 3) {
to[3] = to[2];
to[2] = 0;
}
break;
}
return nhgetl(to);
}
static Bonobo_Persist_ContentTypeList *
impl_Bonobo_Persist_getContentTypes (PortableServer_Servant servant,
CORBA_Environment *ev)
{
BonoboPersist *persist = bonobo_persist_from_servant (servant);
return CLASS (persist)->get_content_types (persist, ev);
}
static MateComponent_Persist_ContentTypeList *
impl_MateComponent_Persist_getContentTypes (PortableServer_Servant servant,
CORBA_Environment *ev)
{
MateComponentPersist *persist = matecomponent_persist_from_servant (servant);
return CLASS (persist)->get_content_types (persist, ev);
}
static Res MFSInit(Pool pool, Arena arena, PoolClass klass, ArgList args)
{
Size extendBy = MFS_EXTEND_BY_DEFAULT;
Bool extendSelf = TRUE;
Size unitSize;
MFS mfs;
ArgStruct arg;
Res res;
AVER(pool != NULL);
AVERT(Arena, arena);
AVERT(ArgList, args);
UNUSED(klass); /* used for debug pools only */
ArgRequire(&arg, args, MPS_KEY_MFS_UNIT_SIZE);
unitSize = arg.val.size;
if (ArgPick(&arg, args, MPS_KEY_EXTEND_BY))
extendBy = arg.val.size;
if (ArgPick(&arg, args, MFSExtendSelf))
extendSelf = arg.val.b;
AVER(unitSize > 0);
AVER(extendBy > 0);
AVERT(Bool, extendSelf);
res = NextMethod(Pool, MFSPool, init)(pool, arena, klass, args);
if (res != ResOK)
goto failNextInit;
mfs = CouldBeA(MFSPool, pool);
mfs->unroundedUnitSize = unitSize;
if (unitSize < UNIT_MIN)
unitSize = UNIT_MIN;
unitSize = SizeAlignUp(unitSize, MPS_PF_ALIGN);
if (extendBy < unitSize)
extendBy = unitSize;
extendBy = SizeArenaGrains(extendBy, arena);
mfs->extendBy = extendBy;
mfs->extendSelf = extendSelf;
mfs->unitSize = unitSize;
mfs->freeList = NULL;
mfs->tractList = NULL;
mfs->total = 0;
mfs->free = 0;
SetClassOfPoly(pool, CLASS(MFSPool));
mfs->sig = MFSSig;
AVERC(MFS, mfs);
EVENT5(PoolInitMFS, pool, arena, extendBy, BOOLOF(extendSelf), unitSize);
return ResOK;
failNextInit:
AVER(res != ResOK);
return res;
}
FILE * get_file(struct IridiumContext * context, object self) {
object reason = NULL;
FILE * f = internal_get_attribute(self, L_ATOM(FILE), FILE *);
if (f == NULL) {
reason = send(self, "to_s");
reason = send(reason, "__add__", IR_STRING(" is not open"));
RAISE(send(CLASS(IOError), "new", reason));
}
return f;
}
static Res BufferAbsInit(Buffer buffer, Pool pool, Bool isMutator, ArgList args)
{
Arena arena;
AVER(buffer != NULL);
AVERT(Pool, pool);
AVER(BoolCheck(isMutator));
AVERT(ArgList, args);
/* Superclass init */
InstInit(CouldBeA(Inst, buffer));
arena = PoolArena(pool);
/* Initialize the buffer. See <code/mpmst.h> for a definition of
the structure. sig and serial comes later .init.sig-serial */
buffer->arena = arena;
buffer->pool = pool;
RingInit(&buffer->poolRing);
buffer->isMutator = isMutator;
if (ArenaGlobals(arena)->bufferLogging) {
buffer->mode = BufferModeLOGGED;
} else {
buffer->mode = 0;
}
buffer->fillSize = 0.0;
buffer->emptySize = 0.0;
buffer->alignment = PoolAlignment(pool);
buffer->base = (Addr)0;
buffer->initAtFlip = (Addr)0;
/* In the next three assignments we really mean zero, not NULL, because
the bit pattern is compared. It's pretty unlikely we'll encounter
a platform where this makes a difference. */
buffer->ap_s.init = (mps_addr_t)0;
buffer->ap_s.alloc = (mps_addr_t)0;
buffer->ap_s.limit = (mps_addr_t)0;
buffer->poolLimit = (Addr)0;
buffer->rampCount = 0;
/* .init.sig-serial: Now the vanilla stuff is initialized, sign the
buffer and give it a serial number. It can then be safely checked
in subclass methods. */
buffer->serial = pool->bufferSerial; /* .trans.mod */
++pool->bufferSerial;
SetClassOfPoly(buffer, CLASS(Buffer));
buffer->sig = BufferSig;
AVERT(Buffer, buffer);
/* Attach the initialized buffer to the pool. */
RingAppend(&pool->bufferRing, &buffer->poolRing);
EVENT3(BufferInit, buffer, pool, BOOLOF(buffer->isMutator));
return ResOK;
}
size_t file_length(struct IridiumContext * context, FILE * f, object filename) {
struct stat st;
object reason = NULL;
if (-1 == fstat(fileno(f), &st)) {
reason = filename;
reason = send(reason, "__add__", IR_STRING(" -- "));
reason = send(reason, "__add__", IR_STRING(strerror(errno)));
RAISE(send(CLASS(IOError), "new", reason));
}
return st.st_size;
}
/*
* Method: Pm_WriteSysEx
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1WriteSysEx
(JNIEnv *env, jclass cl, jobject jstream, jint when, jbyteArray jmsg)
{
CLASS(c, jstream);
ADDRESS_FID(fid, c);
jbyte *bytes = (*env)->GetByteArrayElements(env, jmsg, 0);
PmError rslt = Pm_WriteSysEx(PMSTREAM(jstream, fid), when,
(unsigned char *) bytes);
(*env)->ReleaseByteArrayElements(env, jmsg, bytes, 0);
return rslt;
}
iridium_method(File, write) {
// The string to write
char * str = C_STRING(context, local(str));
size_t len = strlen(str);
FILE * f = internal_get_attribute(local(self), L_ATOM(FILE), FILE *);
size_t written = fwrite(str, sizeof str[0], len, f);
if (written != len) {
RAISE(send(CLASS(IOError), "new", IR_STRING("File not in write mode")));
}
return NIL;
}
/*
* Method: Pm_OpenOutput
*/
JNIEXPORT jint JNICALL Java_jportmidi_JPortMidiApi_Pm_1OpenOutput
(JNIEnv *env, jclass cl, jobject jstream, jint index, jstring extras,
jint bufsiz, jint latency)
{
PmError rslt;
PortMidiStream *stream;
CLASS(c, jstream);
ADDRESS_FID(fid, c);
rslt = Pm_OpenOutput(&stream, index, NULL, bufsiz, NULL, NULL, latency);
SET_PMSTREAM(jstream, fid, stream);
return rslt;
}
static int
parseip(char *name, uint32_t *ip)
{
unsigned char addr[4];
char *p;
int i, x;
p = name;
// ipv4 解析
for(i=0; i<4 && *p; i++){
x = strtoul(p, &p, 0);
// x.x.x.x ipv4 单个字段不会超过 255
if(x < 0 || x >= 256)
return -1;
// 数值接着的应该为 .
if(*p != '.' && *p != 0)
return -1;
if(*p == '.')
p++;
addr[i] = x;
}
// 根据第一个数值的高两位来确定 ip 地址的类型
// 0 为 A 类, 1.0.0.1－126.255.255.254
// 1 为 B 类, 128.1.0.1－191.255.255.254
// 2 为 C 类, 192.0.1.1－223.255.255.254
// 如果不足 4个段，那么低的段使用 0
switch(CLASS(addr)){
case 0:
case 1:
if(i == 3){
addr[3] = addr[2];
addr[2] = addr[1];
addr[1] = 0;
}else if(i == 2){
addr[3] = addr[1];
addr[2] = 0;
addr[1] = 0;
}else if(i != 4)
return -1;
break;
case 2:
if(i == 3){
addr[3] = addr[2];
addr[2] = 0;
}else if(i != 4)
return -1;
break;
}
*ip = *(uint32_t*)addr;
return 0;
}
