コード例 #1
0
static INLINE uint8_t GetTTL (const EncState* enc)
{
    char dir;

    if ( enc->p->packet_flags & PKT_FROM_CLIENT )
        dir = FORWARD(enc) ? SSN_DIR_CLIENT : SSN_DIR_SERVER;
    else
        dir = FORWARD(enc) ? SSN_DIR_SERVER : SSN_DIR_CLIENT;

    return stream_api->get_session_ttl(
        enc->p->ssnptr, dir, !enc->ip_hdr);
}
コード例 #2
0
ファイル: Fsanity.c プロジェクト: 8l/csolve
int
SanityCheck1(Heap * h, Item * i)
{
  Heap * h1;

  if(h == NULL_HEAP)
  {
     return(TRUE);
  }

  h1 = h;
  do
  {
    if(LessThan(ITEM(h1), i))
    {
      return(FALSE);
    }
    if(!SanityCheck1(CHILD(h1), ITEM(h1)))
    {
      return(FALSE);
    }

    h1 = FORWARD(h1);
  }
  while(h1 != h);

  return(TRUE);
}
コード例 #3
0
ファイル: Fsanity.c プロジェクト: 8l/csolve
void
PrettyPrint(Heap * h)
{
  Heap * h1;

  if(h == NULL_HEAP)
  {
    printf(" nil ");
    return;
  }

  printf("(");

  h1 = h;
  do
  {
    PrintItem(ITEM(h1));
    printf("[%u] ", RANK(h1));
    PrettyPrint(CHILD(h1));
    h1 = FORWARD(h1);
  }
  while(h1 != h);

  printf(")");
}
コード例 #4
0
ファイル: mmc.c プロジェクト: Aliandrana/uzebox
DRESULT disk_readp (
	BYTE *buff,		/* Pointer to the read buffer (NULL:Read bytes are forwarded to the stream) */
	DWORD lba,		/* Sector number (LBA) */
	WORD ofs,		/* Byte offset to read from (0..511) */
	WORD cnt		/* Number of bytes to read (ofs + cnt mus be <= 512) */
)
{
	DRESULT res;
	BYTE rc;
	WORD bc;



	if (!(CardType & CT_BLOCK)) lba *= 512;		/* Convert to byte address if needed */

	res = RES_ERROR;
	if (send_cmd(CMD17, lba) == 0) {		/* READ_SINGLE_BLOCK */



		bc = 40000;
		do {							/* Wait for data packet */
			rc = rcv_spi();
		} while (rc == 0xFF && --bc);

		if (rc == 0xFE) {				/* A data packet arrived */
			bc = 514 - ofs - cnt;


			/* Skip leading bytes */
			if (ofs) {
				do rcv_spi(); while (--ofs);
			}

			/* Receive a part of the sector */
			if (buff) {	/* Store data to the memory */
				do {
					*buff++ = rcv_spi();
				} while (--cnt);
			} else {	/* Forward data to the outgoing stream (depends on the project) */
				do {
					FORWARD(rcv_spi());
				} while (--cnt);
			}

			/* Skip trailing bytes and CRC */
			do rcv_spi(); while (--bc);

			res = RES_OK;
		}
	}


	DESELECT();
	rcv_spi();

	return res;
}
コード例 #5
0
ファイル: encode.c プロジェクト: DHODoS/snort
static ENC_STATUS IP4_Encode (EncState* enc, Buffer* in, Buffer* out)
{
    int len;
    uint32_t start = out->end;

    IPHdr* hi = (IPHdr*)enc->p->layers[enc->layer-1].start;
    IPHdr* ho = (IPHdr*)(out->base + out->end);
    PROTO_ID next = NextEncoder(enc);
    UPDATE_BOUND(out, sizeof(*ho));

    /* IPv4 encoded header is hardcoded 20 bytes */
    ho->ip_verhl = 0x45;
    ho->ip_off = 0;

    ho->ip_id = IpId_Next();
    ho->ip_tos = hi->ip_tos;
    ho->ip_proto = hi->ip_proto;

    if ( FORWARD(enc) )
    {
        ho->ip_src.s_addr = hi->ip_src.s_addr;
        ho->ip_dst.s_addr = hi->ip_dst.s_addr;

        ho->ip_ttl = FwdTTL(enc, hi->ip_ttl);
    }
    else
    {
        ho->ip_src.s_addr = hi->ip_dst.s_addr;
        ho->ip_dst.s_addr = hi->ip_src.s_addr;

        ho->ip_ttl = RevTTL(enc, hi->ip_ttl);
    }

    enc->ip_hdr = (uint8_t*)hi;
    enc->ip_len = IP_HLEN(hi) << 2;

    if ( next < PROTO_MAX )
    {
        ENC_STATUS err = encoders[next].fencode(enc, in, out);
        if ( ENC_OK != err ) return err;
    }
    if ( enc->proto )
    {
        ho->ip_proto = enc->proto;
        enc->proto = 0;
    }

    len = out->end - start;
    ho->ip_len = htons((uint16_t)len);

    ho->ip_csum = 0;

    /* IPv4 encoded header is hardcoded 20 bytes, we save some
     * cycles and use the literal header size for checksum */
    ho->ip_csum = in_chksum_ip((const uint16_t *)ho, sizeof *ho);

    return ENC_OK;
}
コード例 #6
0
ファイル: Fsanity.c プロジェクト: 8l/csolve
int
SanityCheck2(Heap * h)
{
  int   sum;
  Heap * h1;
  Heap * h2;

  if(h == NULL_HEAP)
  {
     return(TRUE);
  }

  h1 = h;
  do
  {
    if(CHILD(h1) != NULL_HEAP)
    {
      sum = 0;
      h2 = CHILD(h1);
      do
      {
         sum += RANK(h2) + 1;

         h2 = FORWARD(h2);
      }
      while(h2 != CHILD(h1));
      if(sum != RANK(h1))
      {
        return(FALSE);
      }

      if(!SanityCheck2(CHILD(h1)))
      {
        return(FALSE);
      }
    }

    h1 = FORWARD(h1);
  }
  while(h1 != h);

  return(TRUE);
}
コード例 #7
0
ファイル: avr_mmcp.c プロジェクト: Lembed/Micro-Fs-Mirrors
DRESULT disk_readp (
	BYTE *buff,		/* Pointer to the read buffer (NULL:Forward to the stream) */
	DWORD sector,	/* Sector number (LBA) */
	UINT offset,	/* Byte offset to read from (0..511) */
	UINT count		/* Number of bytes to read (ofs + cnt mus be <= 512) */
)
{
	DRESULT res;
	BYTE rc;
	UINT bc;


	if (!(CardType & CT_BLOCK)) sector *= 512;	/* Convert to byte address if needed */

	res = RES_ERROR;
	if (send_cmd(CMD17, sector) == 0) {	/* READ_SINGLE_BLOCK */

		bc = 40000;	/* Time counter */
		do {				/* Wait for data packet */
			rc = rcv_spi();
		} while (rc == 0xFF && --bc);

		if (rc == 0xFE) {	/* A data packet arrived */

			bc = 512 + 2 - offset - count;	/* Number of trailing bytes to skip */

			/* Skip leading bytes */
			while (offset--) rcv_spi();

			/* Receive a part of the sector */
			if (buff) {	/* Store data to the memory */
				do {
					*buff++ = rcv_spi();
				} while (--count);
			} else {	/* Forward data to the outgoing stream */
				do {
					FORWARD(rcv_spi());
				} while (--count);
			}

			/* Skip trailing bytes and CRC */
			do rcv_spi(); while (--bc);

			res = RES_OK;
		}
	}

	DESELECT();
	rcv_spi();

	return res;
}
コード例 #8
0
ファイル: mmcbb.c プロジェクト: robwasab/TV_B_GONE
DRESULT disk_readp (
	BYTE *buff,		/* Pointer to the read buffer (NULL:Read bytes are forwarded to the stream) */
	DWORD lba,		/* Sector number (LBA) */
	WORD ofs,		/* Byte offset to read from (0..511) */
	WORD cnt		/* Number of bytes to read (ofs + cnt mus be <= 512) */
)
{
	DRESULT res;
	BYTE d;
	WORD bc, tmr;


	if (!(CardType & CT_BLOCK)) lba *= 512;		/* Convert to byte address if needed */

	res = RES_ERROR;
	if (send_cmd(CMD17, lba) == 0) {		/* READ_SINGLE_BLOCK */

		tmr = 1000;
		do {							/* Wait for data packet in timeout of 100ms */
			DLY_US(100);
			d = rcvr_mmc();
		} while (d == 0xFF && --tmr);

		if (d == 0xFE) {				/* A data packet arrived */
			bc = 514 - ofs - cnt;

			/* Skip leading bytes */
			if (ofs) skip_mmc(ofs);

			/* Receive a part of the sector */
			if (buff) {	/* Store data to the memory */
				do
					*buff++ = rcvr_mmc();
				while (--cnt);
			} else {	/* Forward data to the outgoing stream */
				do {
					d = rcvr_mmc();
					FORWARD(d);
				} while (--cnt);
			}

			/* Skip trailing bytes and CRC */
			skip_mmc(bc);

			res = RES_OK;
		}
	}

	release_spi();

	return res;
}
コード例 #9
0
ファイル: encode.c プロジェクト: DHODoS/snort
static inline uint8_t GetTTL (const EncState* enc)
{
    char dir;
    uint8_t ttl;
    int outer = !enc->ip_hdr;

    if ( !enc->p->ssnptr )
        return 0;

    if ( enc->p->packet_flags & PKT_FROM_CLIENT )
        dir = FORWARD(enc) ? SSN_DIR_FROM_CLIENT : SSN_DIR_FROM_SERVER;
    else
        dir = FORWARD(enc) ? SSN_DIR_FROM_SERVER : SSN_DIR_FROM_CLIENT;

    // outermost ip is considered to be outer here,
    // even if it is the only ip layer ...
    ttl = session_api->get_session_ttl(enc->p->ssnptr, dir, outer);

    // so if we don't get outer, we use inner
    if ( 0 == ttl && outer )
        ttl = session_api->get_session_ttl(enc->p->ssnptr, dir, 0);

    return ttl;
}
コード例 #10
0
ファイル: encode.c プロジェクト: DHODoS/snort
static ENC_STATUS Eth_Encode (EncState* enc, Buffer* in, Buffer* out)
{
    // not raw ip -> encode layer 2
    int raw = ( enc->flags & ENC_FLAG_RAW );

    EtherHdr* hi = (EtherHdr*)enc->p->layers[enc->layer-1].start;
    PROTO_ID next = NextEncoder(enc);

    // if not raw ip AND out buf is empty
    if ( !raw && (out->off == out->end) )
    {
        // for alignment
        out->off = out->end = SPARC_TWIDDLE;
    }
    // if not raw ip OR out buf is not empty
    if ( !raw || (out->off != out->end) )
    {
        // we get here for outer-most layer when not raw ip
        // we also get here for any encapsulated ethernet layer.
        EtherHdr* ho = (EtherHdr*)(out->base + out->end);
        UPDATE_BOUND(out, sizeof(*ho));

        ho->ether_type = hi->ether_type;
        if ( FORWARD(enc) )
        {
            memcpy(ho->ether_src, hi->ether_src, sizeof(ho->ether_src));
            /*If user configured remote MAC address, use it*/
            if (NULL != dst_mac)
                memcpy(ho->ether_dst, dst_mac, sizeof(ho->ether_dst));
            else
                memcpy(ho->ether_dst, hi->ether_dst, sizeof(ho->ether_dst));
        }
        else
        {
            memcpy(ho->ether_src, hi->ether_dst, sizeof(ho->ether_src));
            /*If user configured remote MAC address, use it*/
            if (NULL != dst_mac)
                memcpy(ho->ether_dst, dst_mac, sizeof(ho->ether_dst));
            else
                memcpy(ho->ether_dst, hi->ether_src, sizeof(ho->ether_dst));
        }
    }
    if ( next < PROTO_MAX )
        return encoders[next].fencode(enc, in, out);

    return ENC_OK;
}
コード例 #11
0
ファイル: encode.c プロジェクト: DHODoS/snort
static ENC_STATUS FPath_Encode (EncState* enc, Buffer* in, Buffer* out)
{
    // not raw ip -> encode layer 2
    int raw = ( enc->flags & ENC_FLAG_RAW );

    FPathHdr* hi = (FPathHdr*)enc->p->layers[enc->layer-1].start;
    PROTO_ID next = NextEncoder(enc);

    // if not raw ip AND out buf is empty
    if ( !raw && (out->off == out->end) )
    {
        // for alignment
        out->off = out->end = 0;
    }
    // if not raw ip OR out buf is not empty
    if ( !raw || (out->off != out->end) )
    {
        // we get here for outer-most layer when not raw ip
        // we also get here for any encapsulated ethernet layer.
        FPathHdr* ho = (FPathHdr*)(out->base + out->end);
        UPDATE_BOUND(out, sizeof(*ho));

        ho->fpath_type = hi->fpath_type;
        if ( FORWARD(enc) )
        {
            memcpy(ho->fpath_src, hi->fpath_src, sizeof(ho->fpath_src));
            memcpy(ho->fpath_dst, hi->fpath_dst, sizeof(ho->fpath_dst));
        }
        else
        {
            memcpy(ho->fpath_src, hi->fpath_dst, sizeof(ho->fpath_src));
            memcpy(ho->fpath_dst, hi->fpath_src, sizeof(ho->fpath_dst));
        }
    }
    if ( next < PROTO_MAX )
        return encoders[next].fencode(enc, in, out);

    return ENC_OK;
}
コード例 #12
0
static ENC_STATUS Eth_Encode (EncState* enc, Buffer* in, Buffer* out)
{
    int outer = 0;
    int raw = enc->flags & ENC_FLAG_RAW;

    EtherHdr* hi = (EtherHdr*)enc->p->layers[enc->layer-1].start;
    PROTO_ID next = NextEncoder(enc);

    if ( raw && (out->off == out->end) )
    {
        // for alignment
        out->off = out->end = SPARC_TWIDDLE;
        outer = 1;  // encoding outermost eth
    }
    if ( raw || !outer )
    {
        // we get here for outer-most layer when raw is true;
        // we also get here for any encapsulated ethernet layer.
        EtherHdr* ho = (EtherHdr*)(out->base + out->end);
        UPDATE_BOUND(out, sizeof(*ho));

        if ( FORWARD(enc) )
        {
            memcpy(ho, hi, sizeof(*ho));
        }
        else
        {
            ho->ether_type = hi->ether_type;
            memcpy(ho->ether_src, hi->ether_dst, sizeof(ho->ether_src));
            memcpy(ho->ether_dst, hi->ether_src, sizeof(ho->ether_dst));
        }
    }
    if ( next < PROTO_MAX )
        return encoders[next].fencode(enc, in, out);

    return ENC_OK;
}
コード例 #13
0
ファイル: Fsanity.c プロジェクト: 8l/csolve
int
SanityCheck3(Heap * h, int rank)
{
  int   sum;
  Heap * h1;
  Heap * h2;

  if((h == NULL_HEAP) && (rank == 0))
  {
     return(TRUE);
  }

  sum = 0;
  h1 = h;
  do
  {
    sum += RANK(h1) + 1;

    if(!SanityCheck3(CHILD(h1), RANK(h1)))
    {
      return(FALSE);
    }

    h1 = FORWARD(h1);
  }
  while(h1 != h);

  if(sum == rank)
  {
    return(TRUE);
  }
  else
  {
    return(FALSE);
  }
}
コード例 #14
0
/* edge_walker assumes that the current edge is being drawn CCW
 * around the current zone.  Since only boundary edges are drawn
 * and we always walk around with the filled region to the left,
 * no edge is ever drawn CW.  We attempt to advance to the next
 * edge on this boundary, but if current second endpoint is not
 * between the two contour levels, we exit back to zone_crosser.
 * Note that we may wind up marking no points.
 * -- edge_walker is never called for single level case */
static int edge_walker(Csite *site, Cdata *data, int pass2)
{
  long edge= site->edge;
  long left= site->left;
  long n= site->n;
  long fwd= FORWARD(left,site->imax);
  long p0= POINT0(edge,fwd);
  long p1= POINT1(edge,fwd);
  int jedge= IS_JEDGE(edge,left);
  long edge0= site->edge0;
  long left0= site->left0;
  int level0= site->level0==2;
  int marked;

  const GpReal *x= pass2? site->x : 0;
  const GpReal *y= pass2? site->y : 0;
  GpReal *xcp= pass2? site->xcp : 0;
  GpReal *ycp= pass2? site->ycp : 0;

  int z0, z1, heads_up= 0;

  for (;;) {
    /* mark endpoint 0 only if value is 1 there, and this is a
     * two level task */
    z0= data[p0]&Z_VALUE;
    z1= data[p1]&Z_VALUE;
    marked= 0;
    if (z0==1) {
      /* mark current boundary point */
      if (pass2) {
	xcp[n]= x[p0];
	ycp[n]= y[p0];
      }
      marked= 1;
    } else if (!n) {
      /* if this is the first point is not between the levels
       * must do the job of the zone_crosser and mark the first cut here,
       * so that it will be marked again by zone_crosser as it closes */
      if (pass2) {
	GpReal zcp= site->zlevel[(z0!=0)];
	zcp= (zcp-site->z[p0])/(site->z[p1]-site->z[p0]);
	xcp[n]= zcp*(x[p1]-x[p0]) + x[p0];
	ycp[n]= zcp*(y[p1]-y[p0]) + y[p0];
      }
      marked= 1;
    }
    if (n) {
      /* check for closure */
      if (level0 && edge==edge0 && left==left0) {
	site->edge= edge;
	site->left= left;
	site->n= n+marked;
	/* if the curve is closing on a hole, need to make a downslit */
	if (fwd<0 && !(data[edge]&(jedge?J_BNDY:I_BNDY)))
	  return slit_cutter(site, data, 0, pass2);
	return 3;
      } else if (pass2) {
	if (heads_up || (fwd<0 && (data[edge]&SLIT_DN))) {
	  site->edge= edge;
	  site->left= left;
	  site->n= n+marked;
	  return slit_cutter(site, data, heads_up, pass2);
	}
      } else {
	/* if this is not first point, clear start mark for this edge */
	Cdata start= data[edge]&START_MARK(left);
	if (start) { data[edge]&=~start; site->count--; }
      }
    }
    if (marked) n++;

    /* if next endpoint not between levels, need to exit to zone_crosser */
    if (z1!=1) {
      site->edge= edge;
      site->left= left;
      site->n= n;
      return (z1!=0);      /* return level closest to p1 */
    }

    /* step to p1 and find next edge
     * -- turn left if possible, else straight, else right
     * -- check for upward slit beginning at same time */
    edge= p1 + (left>0? left : 0);
    if (pass2 && jedge && fwd>0 && (data[edge]&SLIT_UP)) {
      jedge= !jedge;
      heads_up= 1;
    } else if (data[edge]&(jedge?I_BNDY:J_BNDY)) {
      long tmp=fwd; fwd=left; left=-tmp;
      jedge= !jedge;
    } else {
      edge= p1 + (fwd>0? fwd : 0);
      if (pass2 && !jedge && fwd>0 && (data[edge]&SLIT_UP)) {
	heads_up= 1;
      } else if (!(data[edge]&(jedge?J_BNDY:I_BNDY))) {
	edge= p1 - (left<0? left : 0);
	jedge= !jedge;
	{ long tmp=fwd; fwd=-left; left=tmp; }
      }
    }
    p0= p1;
    p1= POINT1(edge,fwd);
  }
}
コード例 #15
0
ファイル: mmc.c プロジェクト: rexut/mist-board
DRESULT disk_readp (
	BYTE *buff,		/* Pointer to the read buffer (NULL:Read bytes are forwarded to the stream) */
	DWORD sector,	/* Sector number (LBA) */
	UINT offset,	/* Byte offset to read from (0..511) */
	UINT count		/* Number of bytes to read (ofs + cnt mus be <= 512) */
)
{
        BYTE *buff_sec = buffer;
	DRESULT res;
	BYTE d;
	UINT bc, tmr;

	if (!(CardType & CT_BLOCK)) sector *= 512;	/* Convert to byte address if needed */

	// check if sector is already in sector buffer
	if(buffer_sector == sector) {
	  buff_sec += offset;  // skip to requested bytes
	  while(count--)
	    *buff++ = *buff_sec++;

	  return RES_OK;
	}

	res = RES_ERROR;
	if (send_cmd(CMD17, sector) == 0) {		/* READ_SINGLE_BLOCK */

		tmr = 1000;
		do {							/* Wait for data packet in timeout of 100ms */
			DLY_US(100);
			d = rcvr_mmc();
		} while (d == 0xFF && --tmr);

		if (d == 0xFE) {				/* A data packet arrived */
			bc = 512 - offset - count;

			/* Skip leading bytes (store in buffer only) */
			while(offset--)
			  *buff_sec++ = rcvr_mmc();

			/* Receive a part of the sector */
			if (buff) {	/* Store data to the memory */
			    do
			        *buff_sec++ = *buff++ = rcvr_mmc();
			    while (--count);
			} else {	/* Forward data to the outgoing stream */
				do {
					*buff_sec++ = d = rcvr_mmc();
					FORWARD(d);
				} while (--count);
			}

			/* Skip trailing bytes (store in buffer only) */
			while(bc--)
			  *buff_sec++ = rcvr_mmc();
			
			/* and skip crc */
			skip_mmc(2);

			buffer_sector = sector;
			res = RES_OK;
		}
	}

	release_spi();

	return res;
}
コード例 #16
0
static ENC_STATUS IP4_Encode (EncState* enc, Buffer* in, Buffer* out)
{
    int len;
    uint32_t start = out->end;

    IPHdr* hi = (IPHdr*)enc->p->layers[enc->layer-1].start;
    IPHdr* ho = (IPHdr*)(out->base + out->end);
    PROTO_ID next = NextEncoder(enc);
    UPDATE_BOUND(out, sizeof(*ho));

    len = GET_IP_HDR_LEN(hi) - sizeof(*hi);

    ho->ip_verhl = 0x45;
    ho->ip_off = 0;

    ho->ip_id = IpId_Next();
    ho->ip_tos = hi->ip_tos;
    ho->ip_proto = hi->ip_proto;

    if ( FORWARD(enc) )
    {
        uint8_t ttl = AdjTTL(hi->ip_ttl);

        ho->ip_src.s_addr = hi->ip_src.s_addr;
        ho->ip_dst.s_addr = hi->ip_dst.s_addr;

        if ( enc->p->ssnptr )
            ttl = GetTTL(enc);

#ifdef NORMALIZER
        if ( ttl < ScMinTTL() && ScNewTTL() )
            ttl = ScNewTTL();
#endif
        ho->ip_ttl = ttl;
    }
    else
    {
        uint8_t ttl = MAX_TTL;

        ho->ip_src.s_addr = hi->ip_dst.s_addr;
        ho->ip_dst.s_addr = hi->ip_src.s_addr;

        if ( enc->p->ssnptr )
            ttl = GetTTL(enc);

#ifdef NORMALIZER
        if ( ttl < ScMinTTL() && ScNewTTL() )
            ttl = ScNewTTL();
#endif
        ho->ip_ttl = ttl;
    }

    enc->ip_hdr = (uint8_t*)hi;
    enc->ip_len = IP_HLEN(hi) << 2;

    if ( next < PROTO_MAX )
    {
        int err = encoders[next].fencode(enc, in, out);
        if ( err ) return err;
    }  
    if ( enc->proto )
    {
        ho->ip_proto = enc->proto;
        enc->proto = 0;
    }
    len = out->end - start;
    ho->ip_len = htons((u_int16_t)len);
    ip_checksum(ho, len);

    return ENC_OK;
}
コード例 #17
0
ファイル: agar-disasm.c プロジェクト: LiberatorUSA/GUCEF
int
main(int argc, char *argv[])
{
	char *file, *s;
	extern char *optarg;
	extern int optind;
	int i, c;
	AG_DataSource *ds = NULL;
	AG_ObjectHeader oh;
	Uint32 pos, sLen;
	size_t len;
	Uint8 *buf, *p;
	int asis = 0;

	if (AG_InitCore("agar-disasm", 0) == -1) {
		return (0);
	}
	while ((c = getopt(argc, argv, "?")) != -1) {
		switch (c) {
		case '?':
		default:
			printusage();
			return (1);
		}
	}
	if (argc < 2) {
		printusage();
		return (1);
	}
	file = argv[1];

	if ((ds = AG_OpenFile(file, "r")) == NULL) {
		goto fail;
	}
	if (AG_ObjectReadHeader(ds, &oh) == -1) {
		goto fail;
	}
	printf("Class:\t\t%s\n", oh.cs.hier);
	if (oh.cs.libs[0] != '\0') {
		printf("Modules:\t%s\n", oh.cs.libs);
	}
	printf("Dataset at:\t%lx\n", (unsigned long)oh.dataOffs);
	printf("Version:\t%u.%u\n", oh.ver.major, oh.ver.minor);
	printf("Flags:\t\t0x%x\n", oh.flags);
	printf("\n");

	if (AG_Seek(ds, 0, AG_SEEK_END) == -1) {
		goto fail;
	}
	len = AG_Tell(ds) - oh.dataOffs;
	if (AG_Seek(ds, (off_t)oh.dataOffs, AG_SEEK_SET) == -1) {
		goto fail;
	}
	pos = 0;

	if ((buf = malloc(len)) == NULL) {
		AG_SetError("Out of memory for dataset (%lu)",
		    (unsigned long)len);
		goto fail;
	}
	if (AG_Read(ds, buf, len) == -1)
		goto fail;

	for (p = buf; ;) {
		for (i = 0; i < nTypes; i++) {
			if (AG_SwapBE32(*(Uint32 *)p) == types[i].type) {
				if (asis) {
					printf("\n");
				}
				asis = 0;
				break;
			}
		}
		if (i == nTypes) {
			if (!asis) {
				printf("[%8s] ", "???");
				asis = 1;
			}
			if (isprint(*(Uint8 *)p)) {
				fputc(*(Uint8 *)p, stdout);
			} else {
				printf("\\%x", *(Uint8 *)p);
			}
			FORWARD(1);
			continue;
		}
		FORWARD(4);

		printf("[%8s] ", types[i].name);
		switch (types[i].type) {
		case AG_SOURCE_UINT8:
			printf("%u\n", *(Uint8 *)p);
			FORWARD(1);
			break;
		case AG_SOURCE_UINT16:
			{
				Uint16 v = AG_SwapBE16(*(Uint16 *)p);
				printf("%u\n", (unsigned)v);
				FORWARD(2);
			}
			break;
		case AG_SOURCE_UINT32:
			{
				Uint32 v = AG_SwapBE32(*(Uint32 *)p);
				printf("%lu\n", (unsigned long)v);
				FORWARD(4);
			}
			break;
#ifdef HAVE_64BIT
		case AG_SOURCE_UINT64:
			{
				Uint64 v = AG_SwapBE64(*(Uint64 *)p);
				printf("%llu\n", (unsigned long long)v);
				FORWARD(8);
			}
			break;
#endif
		case AG_SOURCE_FLOAT:
			{
				float f = AG_SwapBEFLT(*(float *)p);
				printf("%f\n", f);
				FORWARD(4);
			}
			break;
		case AG_SOURCE_DOUBLE:
			{
				double f = AG_SwapBEDBL(*(double *)p);
				printf("%f\n", f);
				FORWARD(8);
			}
			break;
#ifdef HAVE_LONG_DOUBLE
		case AG_SOURCE_LONG_DOUBLE:
			{
				long double f=AG_SwapBELDBL(*(long double *)p);
				printf("%Lf\n", f);
				FORWARD(16);
			}
			break;
#endif
		case AG_SOURCE_STRING:
			if (AG_SwapBE32(*(Uint32 *)p) != AG_SOURCE_UINT32) {
				printf("Bad string length!\n");
				break;
			}
			FORWARD(4);
			sLen = AG_SwapBE32(*(Uint32 *)p);
			FORWARD(4);
			if ((s = malloc(sLen+1)) == NULL) {
				printf("Out of memory for string!\n");
				break;
			}
			memcpy(s, p, sLen);
			s[sLen] = '\0';
			printf("\"%s\"\n", s);
			free(s);
			FORWARD(sLen);
			break;
		default:
			printf("(skipping)\n");
			break;
		}
	}
out:
	AG_CloseFile(ds);
	return (0);
fail:
	fprintf(stderr, "%s\n", AG_GetError());
	if (ds != NULL) { AG_CloseFile(ds); }
	AG_Destroy();
	return (1);
}
コード例 #18
0
ファイル: WrapperOwner.cpp プロジェクト: vladikoff/gecko-dev
bool
DOMInstanceOf(JSContext* cx, JSObject* proxy, int prototypeID, int depth, bool* bp)
{
    FORWARD(domInstanceOf, (cx, proxy, prototypeID, depth, bp));
}
コード例 #19
0
int main()
{
    DDRC	= 0xFF;			
	PORTC	= 0x00;			
	DDRD	= 0x00;			
	PORTD	= 0xFF;	
	
	UCSR0B	= 0x00;
			
	while(1)
	{
		while(tst_bit(PIND, B_ENABLE));
		_delay_ms(10);
		set_bit(PORTC, ENA);
		set_bit(PORTC, ENB);		
		while(!tst_bit(PIND, B_ENABLE))
		{
			if(!tst_bit(PIND, B_FORWARD))
			{
				_delay_ms(10);
				FORWARD();		
				while(!tst_bit(PIND, B_FORWARD));
				_delay_ms(10);		
			}			
			if(!tst_bit(PIND, B_BACKWARD))
			{
				_delay_ms(10);
				BACKWARD();
				while(!tst_bit(PIND, B_BACKWARD));	
				_delay_ms(10);			
			}				
			if(!tst_bit(PIND, B_STOP))
			{
				_delay_ms(10);
				STOP();
				while(!tst_bit(PIND, B_STOP));		
				_delay_ms(10);		
			}				
			if(!tst_bit(PIND, B_RIGHT))
			{
				_delay_ms(10);
				RIGHT();
				while(!tst_bit(PIND, B_RIGHT));		
				_delay_ms(10);		
			}				
			if(!tst_bit(PIND, B_LEFT))
			{
				_delay_ms(10);
				LEFT();
				while(!tst_bit(PIND, B_LEFT));		
				_delay_ms(10);		
			}				
			if(!tst_bit(PIND, B_MOVE_ON))
			{
				_delay_ms(10);
				MOVE_ON();
				while(!tst_bit(PIND, B_MOVE_ON));		
				_delay_ms(10);		
			}				
		}
		_delay_ms(10);
		clr_bit(PORTC, ENA);
		clr_bit(PORTC, ENB);		
	}	
} /*MAIN*/
コード例 #20
0
/* zone_crosser assumes you are sitting at a cut edge about to cross
 * the current zone.  It always marks the initial point, crosses at
 * least one zone, and marks the final point.  On non-boundary i-edges,
 * it is responsible for removing start markers on the first pass.  */
static int zone_crosser(Csite *site, Cdata *data, int level, int pass2)
{
  long edge= site->edge;
  long left= site->left;
  long n= site->n;
  long fwd= FORWARD(left,site->imax);
  long p0, p1;
  int jedge= IS_JEDGE(edge,left);
  long edge0= site->edge0;
  long left0= site->left0;
  int level0= site->level0==level;
  int two_levels= site->zlevel[1]>site->zlevel[0];
  short *triangle= site->triangle;

  const GpReal *x= pass2? site->x : 0;
  const GpReal *y= pass2? site->y : 0;
  const GpReal *z= pass2? site->z : 0;
  GpReal zlevel= pass2? site->zlevel[level] : 0.0;
  GpReal *xcp= pass2? site->xcp : 0;
  GpReal *ycp= pass2? site->ycp : 0;

  int z0, z1, z2, z3;
  int keep_left= 0;  /* flag to try to minimize curvature in saddles */
  int done= 0;

  if (level) level= 2;

  for (;;) {
    /* set edge endpoints */
    p0= POINT0(edge,fwd);
    p1= POINT1(edge,fwd);

    /* always mark cut on current edge */
    if (pass2) {
      /* second pass actually computes and stores the point */
      GpReal zcp= (zlevel-z[p0])/(z[p1]-z[p0]);
      xcp[n]= zcp*(x[p1]-x[p0]) + x[p0];
      ycp[n]= zcp*(y[p1]-y[p0]) + y[p0];
    }
    if (!done && !jedge) {
      if (n) {
	/* if this is not the first point on the curve, and we're
	 * not done, and this is an i-edge, check several things */
	if (!two_levels && !pass2 && (data[edge]&OPEN_END)) {
	  /* reached an OPEN_END mark, skip the n++ */
	  done= 4;   /* same return value 4 used below */
	  break;
	}

	/* check for curve closure -- if not, erase any start mark */
	if (edge==edge0 && left==left0) {
	  /* may signal closure on a downstroke */
	  if (level0) done= (!pass2 && two_levels && left<0)? 5 : 3;
	} else if (!pass2) {
	  Cdata start= data[edge]&(fwd>0?I0_START:I1_START);
	  if (start) { data[edge]&=~start; site->count--; }
	  if (!two_levels) {
	    start= data[edge]&(fwd>0?I1_START:I0_START);
	    if (start) { data[edge]&=~start; site->count--; }
	  }
	}
      }
    }
    n++;
    if (done) break;

    /* cross current zone to another cut edge */
    z0= (data[p0]&Z_VALUE) != level;     /* 1 if fill toward p0 */
    z1= !z0;                             /* know level cuts edge */
    z2= (data[p1+left]&Z_VALUE) != level;
    z3= (data[p0+left]&Z_VALUE) != level;
    if (z0==z2) {
      if (z1==z3) {
	/* this is a saddle zone, need triangle to decide
	 * -- set triangle if not already decided for this zone */
	long zone= edge + (left>0? left : 0);
	if (triangle) {
	  if (!triangle[zone]) {
	    if (keep_left) triangle[zone]= jedge? -1 : 1;
	    else triangle[zone]= jedge? 1 : -1;
	  }
	  if (triangle[zone]>0? !jedge : jedge) goto bkwd;
	} else {
	  if (keep_left) goto bkwd;
	}
      }
      /* bend forward (right along curve) */
      keep_left= 1;
      jedge= !jedge;
      edge= p1 + (left>0? left : 0);
      { long tmp=fwd; fwd=-left; left=tmp; }
    } else if (z1==z3) {
    bkwd:
      /* bend backward (left along curve) */
      keep_left= 0;
      jedge= !jedge;
      edge= p0 + (left>0? left : 0);
      { long tmp=fwd; fwd=left; left=-tmp; }
    } else {
      /* straight across to opposite edge */
      edge+= left;
    }
    /* after crossing zone, edge/left/fwd is oriented CCW relative to
     * the next zone, assuming we will step there */

    /* now that we've taken a step, check for the downstroke
     * of a slit on the second pass (upstroke checked above)
     * -- taking step first avoids a race condition */
    if (pass2 && two_levels && !jedge) {
      if (left>0) {
	if (data[edge]&SLIT_UP) done= 6;
      } else {
	if (data[edge]&SLIT_DN) done= 5;
      }
    }

    if (!done) {
      /* finally, check if we are on a boundary */
      if (data[edge] & (jedge?J_BNDY:I_BNDY)) {
	done= two_levels? 2 : 4;
	/* flip back into the zone that exists */
	left= -left;
	fwd= -fwd;
	if (!pass2 && (edge!=edge0||left!=left0)) {
	  Cdata start= data[edge]&START_MARK(left);
	  if (start) { data[edge]&=~start; site->count--; }
	}
      }
    }
  }

  site->edge= edge;
  site->n= n;
  site->left= left;
  return done>4? slit_cutter(site, data, done-5, pass2) : done;
}
コード例 #21
0
bool
DOMInstanceOf(JSContext* cx, JSObject* proxyArg, int prototypeID, int depth, bool* bp)
{
    RootedObject proxy(cx, proxyArg);
    FORWARD(domInstanceOf, (cx, proxy, prototypeID, depth, bp), false);
}
コード例 #22
0
ファイル: AggregateMeta.cpp プロジェクト: cancamilo/amarok
        , m_collection( coll )
        , m_editors( editors )
    {}

    void beginUpdate()
    {
        m_batchMode = true;
        foreach( TrackEditorPtr ec, m_editors ) ec->beginUpdate();
    }
    void endUpdate()
    {
        foreach( TrackEditorPtr ec, m_editors ) ec->endUpdate();
        m_batchMode = false;
        QTimer::singleShot( 0, m_collection, SLOT(slotUpdated()) );
    }
    void setComment( const QString &newComment ) { FORWARD( setComment( newComment ) ) }
    void setTrackNumber( int newTrackNumber ) { FORWARD( setTrackNumber( newTrackNumber ) ) }
    void setDiscNumber( int newDiscNumber ) { FORWARD( setDiscNumber( newDiscNumber ) ) }
    void setBpm( const qreal newBpm ) { FORWARD( setBpm( newBpm ) ) }
    void setTitle( const QString &newTitle ) { FORWARD( setTitle( newTitle ) ) }
    void setArtist( const QString &newArtist ) { FORWARD( setArtist( newArtist ) ) }
    void setAlbum( const QString &newAlbum ) { FORWARD( setAlbum( newAlbum ) ) }
    void setAlbumArtist( const QString &newAlbumArtist ) { FORWARD( setAlbumArtist ( newAlbumArtist ) ) }
    void setGenre( const QString &newGenre ) { FORWARD( setGenre( newGenre ) ) }
    void setComposer( const QString &newComposer ) { FORWARD( setComposer( newComposer ) ) }
    void setYear( int newYear ) { FORWARD( setYear( newYear ) ) }
private:
    bool m_batchMode;
    Collections::AggregateCollection *m_collection;
    QList<TrackEditorPtr> m_editors;
};