Ejemplo n.º 1
0
int check_printer_status(){
	struct stat buf;
	//printf("%s\n", printer);
	int r = stat(printer, &buf);
	if (r<0) {
		if (printer_ready != 0) {
			printf("Printer offline\n");
		}
		printer_ready = 0;
		if (errno == ENOENT) {
			printf("Printer not detected\n");
		} else {
			perror("stat");
			return -1;
		}
	} else {
		if (printer_ready != 1) {
			printf("Printer online\n");
			print_loop(printer, queue_dir);
		}
		printer_ready = 1;
	}
	return 0;
}
Ejemplo n.º 2
0
/* ------------------------------------------------------------------
 * Given a string to a file or path, first determines the full 'real' path.
 *
 * If the filename is a symlink, we resolve the link and call this function
 * again, with the from_link flag set.  This is used in deciding which
 * parameter (filename or fullpath) to use when calling lstat, and in
 * determining whether it is necessary to check for loops in the directory
 * hierarchy.
 *
 * If the filename is actually a directory, (and is not already open),
 * explore_dir is called to take care of its entries.  If the directory is
 * found within the visited_dir list, then we have found a loop, and the
 * directory is not explored.
 *
 * Otherwise, it's a regular ol' file and we just call read_file on it.
 *
 * list:	Linked list of visited directories.  Loops are detected
 *		by comparing absolute pathnames.
 * filename:	Name of entity being examined (directory or file).
 * fullpath:	Buffer to hold the full pathname of a file.
 * dir_d:	Maxmimum allowed depth of directory recursion to perform.
 * from_link:	Flag denoting whether this function has been called from
 *		a symbolic link or not.
 * ------------------------------------------------------------------
 */
int process_entry(params *P, visited_dir *list, char *filename,
		  char *path, int dir_d, int from_link)
{
	struct stat statbuf;
	dev_t dev;
	ino_t ino;
	char *absolute_filename;
	int myerrno;
	if ((absolute_filename = malloc(path_size)) == NULL)
	{
		fprintf(stderr, "Malloc failed in process_entry.\n");
		return -1;
	}
	pthread_mutex_lock(&chdir_mutex);
	chdir(path);
	if (lstat(filename, &statbuf) < 0)
	{
		myerrno = errno;
		pthread_mutex_unlock(&chdir_mutex);
		if (filename[0] == '/')
		{
			snprintf(absolute_filename,path_size, "%s", filename);
		}
		else
		{
			snprintf(absolute_filename,path_size, "%s/%s", 
				path, filename);
		}
		if (!enabled(P, NO_SYMLINKS) || (myerrno != ELOOP))
			print_file_error(P, myerrno, absolute_filename);
		free(absolute_filename);
		return 0;
	}

	if (realpath(filename, absolute_filename) == 0)
	{
		myerrno = errno;
		pthread_mutex_unlock(&chdir_mutex);
		if (filename[0] == '/')
		{
			snprintf(absolute_filename,path_size, "%s", filename);
		}
		else
		{
			snprintf(absolute_filename,path_size, "%s/%s", 
				path, filename);
		}

		if (!enabled(P, NO_SYMLINKS) || (myerrno != ELOOP))
			print_file_error(P, myerrno, absolute_filename);
		free(absolute_filename);
		return 0;
	}
	if ( S_ISLNK(statbuf.st_mode))
	{ /* symbolic link: could be either file or dir, so resolve & process */
		if (!enabled(P, NO_SYMLINKS))
		{
			if (lstat(absolute_filename, &statbuf) < 0)
			{
				myerrno = errno;
				pthread_mutex_unlock(&chdir_mutex);
				/*snprintf(absolute_filename,path_size, "%s/%s", 
						path, filename);*/
				print_file_error(P, myerrno, absolute_filename);

				free(absolute_filename);
				return 0;
			}
		}
		else
		{
			free(absolute_filename);
			return 0;
		}
	}
	pthread_mutex_unlock(&chdir_mutex);
	dev = statbuf.st_dev;
	ino = statbuf.st_ino;
	myerrno = 0;
	if (S_ISREG(statbuf.st_mode) || S_ISCHR(statbuf.st_mode))
	{ /* regular, readable file */
		read_file(P, absolute_filename);
		inc_stat(P, t_infiles, 1);
		free(absolute_filename);
	}
	else if (!S_ISDIR(statbuf.st_mode))
	{ /* if not link, file, or dir, error (if appropriate) */
		print_file_error(P, 0, absolute_filename);
		free(absolute_filename);
		return 0;
	}
		
	else if (S_ISDIR(statbuf.st_mode) && dir_d != 0)
	{ /* directory, and dir_depth allows us to explore it */
		if(have_visited(list, dev, ino))
		{ /* if loop found, print it, but don't explore */
			inc_stat(P, t_dloops, 1);
			if (!enabled(P, QUIET_FILENAME))
			{
				print_loop(P, filename, path, 
					absolute_filename, list, dev, ino);
			}
			free(absolute_filename);
		}
		else
		{ /* add a list node, explore the dir, then free the node */
			handle_directory(P, list, absolute_filename, 
				dev, ino, path, (dir_d - 1));
		}
	}
	else if (S_ISDIR(statbuf.st_mode) && dir_d == 0)
	{
		inc_stat(P, t_dskips, 1);
		free(absolute_filename);
	}
	return 0;
}
Ejemplo n.º 3
0
static int outputSeq()
{
     int dev;
     SRC_NODE *node, *brnode;
     COMMON_NODE  *comnode; 
     FILE     *fd;

     if (start_node == NULL)
         return(0);

     if (open_fds() < 1)
         return (0);
     node = start_node;
     while (node != NULL) {
        dev = node->device;
        if (dev < 1)
             dev = 1;
        fd = fds[dev];
        if (fd == NULL) {
            node = node->dnext;
            continue;
        }
        comnode = (COMMON_NODE *) &node->node.common_node;
        switch (node->type) {
          case ACQUIRE: 
          case SAMPLE:   // sample
          case JFID: 
          case FIDNODE: 
                   acquire(node);
                   break;
          case DELAY:
          case INCDLY:  // incdelay
          case VDELAY:  // vdelay
          case VDLST:   // vdelay_list
                   break;
          case PULSE: 
          case SMPUL:   // simpulse, sim3pulse
                   pulse(node);
                   break;
          case SHPUL:
          case SHVPUL:
          case SMSHP:
          case APSHPUL: // apshaped_pulse, apshaped_decpulse,apshaped_dec2pulse
          case OFFSHP:  // shapedpulselist, genRFShapedPulseWithOffset
                   shapepulse(node);
                   break;
          case GRPPULSE: // GroupPulse, TGroupPulse
                   shapepulse(node);
                   break;
          case SHACQ:  // ShapedXmtNAcquire
          case SPACQ:  // SweepNOffsetAcquire, SweepNAcquire
                   acquire(node);
                   break;
          case HLOOP: // starthardloop
                   print_loop(node, 1);
                   break;
          case ENDHP: 
                   print_loop(node, 0);
                   break;
          case SLOOP:  // loop
          case GLOOP:  // gemini loop
          case MSLOOP: // msloop
          case PELOOP: // peloop
          case PELOOP2: // peloop2
          case NWLOOP: // nwloop
                   print_loop(node, 1);
                   break;
          case ENDSP:    // endloop
          case ENDSISLP:  // endpeloop, endmsloop, endpeloop2
          case NWLOOPEND: // endnwloop
                   print_loop(node, 0);
                   break;
          case STATUS: 
          case SETST: 
                   break;
          case GRAD: 
          case RGRAD: 
                   gradient(node, 0);
                   break;
          case MGPUL:  // magradpulse, vagradpulse, simgradpulse, oblique_gradpulse
                   pulse(node);
                   break;
          case MGRAD: // magradient, vagradient,simgradient
                   gradient(node, 0);
                   break;
          case OBLGRAD:  // obl_gradient,oblique_gradient,pe_oblshapedgradient
                   gradient(node, 0);
                   break;
          case PEGRAD:  // pe_gradient,pe2_gradient,phase_encode_gradient
                   gradient(node, 1);
                   break;
          case OBLSHGR: // obl_shapedgradient,obl_shaped3gradient,oblique_shapedgradient
          case SHGRAD:  // shapedgradient,shaped2Dgradient,mashapedgradient
                   shapepulse(node);
                   break;
          case PEOBLG:  // deprecated
                   break;
          case PESHGR:  // pe_shaped3gradient,pe3_shaped3gradient,pe2_shaped3gradient
          case SHVGRAD: // shapedvgradient
          case SHINCGRAD: // shapedincgradient,shaped_INC_gradient
          case PEOBLVG:
                   shapepulse(node);
                   break;
          case DPESHGR:  // pe3_shaped3gradient_dual 
                   shapepulse(node);
                   brnode = node->bnode;
                   if (brnode != NULL) {
                      brnode->xstime = node->xstime;
                      brnode->xetime = node->xetime;
                      brnode->ptime = node->ptime;
                      shapepulse(brnode);
                   }
                   break;
          case PRGON:  // obsprgon,decprgon,dec2prgon
                   break;
          case XPRGON:
                   break;
          case VPRGON:  // obsprgonOffset,decprgonOffset
                   break;
          case PRGMARK: 
          case VPRGMARK: 
                   break;
          case VGRAD:   // vgradient,Pvgradient,S_vgradient
                   gradient(node, 0);
                   break;
          case INCGRAD:  // incgradient,Sincgradient,Wincgradient
                   break;
          case ZGRAD: // zgradpulse
                   pulse(node);
                   break;
          case DEVON:  // xmtron,rfon,decon, rfoff,decoff,xmtroff
                   update_height(node);
                   break;
          case VDEVON: 
                   update_height(node);
                   break;
          case RFONOFF: 
                   update_height(node);
                   break;
          case PWRF: 
          case PWRM: 
          case RLPWRF: 
          case VRLPWRF: 
          case RLPWRM:
                   break;
          case DECLVL:  // declvlon, declvloff
                   break;
          case RLPWR: 
          case DECPWR: 
          case POWER: 
                   break;
          case OFFSET: // offset,ioffset,decoffset,obsoffset 
          case POFFSET: // poffset_list,position_offset,position_offset_list
                   break;
          case LOFFSET: 
                   break;
          case VFREQ:  // vfreq
          case VOFFSET: // voffset
                   break;
          case LKHLD:  // lk_hold
                   break;
          case LKSMP:  // lk_sample
                   break;
          case AMPBLK:  // decblankon,obsunblank,decunblank,blankingon
                   break;
          case SPINLK:  // spinlock, decspinlock,genspinlock
                   print_item(dev, ITEM, node->type, node->fname);
                   if (comnode->vlabel[0] != NULL)
                       print_item(dev, PATTERN, 0, comnode->vlabel[0]);
                   print_size(dev, 1);
                   // time, duration, cycles
                   fprintf(fd, "%.3f %g %g 0 0 1\n", node->xstime,comnode->fval[0],
                          (double)comnode->val[2] );
                   break;
          case XGATE: 
                   print_item(dev, ITEM, node->type, node->fname);
                   print_size(dev, 1);
                   fprintf(fd, "%.3f %g 0 0 0 1\n", node->xstime,comnode->fval[0]);
                   break;
          case ROTORP:   // rotorperiod
          case ROTORS:   // rotorsync
          case BGSHIM: 
                   break;
          case SHSELECT: 
          case GRADANG: 
                   break;
          case ROTATEANGLE: // rot_angle_list
          case EXECANGLE:   // exe_grad_rotation
                   break;
          case SETRCV:     // setreceiver
                   break;
          case SPHASE:    // xmtrphase, dcplrphase, dcplr2phase, dcplr3phase
                   break;
          case PSHIFT:   // phaseshift
                   break;
          case PHASE:    // txphase, decphase
                   break;
          case SPON: // sp1on, sp2on
                   break;
          case RCVRON:   // rcvron, recon, recoff, rcvroff
                   break;
          case PRGOFF:  // prg_dec_off,obsprgoff,decprgoff,dec2prgoff
          case XPRGOFF: 
                   break;
          case HDSHIMINIT:   // hdwshiminit
                   break;
          case ROTATE:  // rotate, rotate_angle
                   break;
          case DCPLON: 
                   break;
          case DCPLOFF: 
          case XDEVON: 
                   break;
          case XTUNE:   // set4Tune
                   break;
          case XMACQ:   // XmtNAcquire
                   acquire(node);
                   break;
          case ACQ1:    // startacq
                   break;
          case TRIGGER:  // triggerSelect
          case SETGATE:  // setMRIUserGates
                   break;
          case RDBYTE:   // readMRIUserByte
                   read_MRIByte(node);
                   break;
          case WRBYTE:   // writeMRIUserByte
                   write_MRIByte(node);
                   break;
          case SETANGLE:  // set_angle_list
                   break;
          case ACTIVERCVR: // setactivercvrs
                   break;
          case PARALLELSTART: 
                   break;
          case PARALLELEND: 
                   break;
          case XEND: 
                   break;
          case XDOCK:
                   break;
          case PARALLELSYNC: 
                   break;
          case RLLOOP:   // rlloop 
          case KZLOOP:   // kzloop
                   print_loop(node, 1);
                   break;
          case RLLOOPEND: // rlendloop
          case KZLOOPEND: // kzendloop
                   print_loop(node, 0);
                   break;
          default:
                   // Wprintf("dps draw: unknown code %d \n", node->type);
                   break;
        }

        node = node->dnext;
     }

     end_channels();
     return (1);
}
Ejemplo n.º 4
0
/* Walk through intermediate tree and generate code. */
void im_codegen (inst_t * head)
{
  /* Handle threads */
  static int thread_cnt = 0;
  if (bfthreads)
    {
      fprintf (bfout, "void *bf%d (void *x) {\n", thread_cnt);
      fprintf (bfout, "  int ptri = %d;\n\n", thread_cnt);
      thread_cnt++;
    }

  indent = 1;

  int returned = 0;

  inst_t *inst = head;
  while (inst != NULL)
    {
      lineno = inst->lineno;
      if (inst->comment && pass_comments)
	{
	  fprintf (bfout, "/*\n %s \n*/\n", inst->comment);
	}

      switch (inst->inst * !returned)
	{
	case IM_CINC:		/* Cell increment */
	  print_incdec ('+', inst->src);
	  break;

	case IM_CDEC:		/* Cell decrement */
	  print_incdec ('-', inst->src);
	  break;

	case IM_PRGHT:		/* Move pointer right */
	  print_move ('>', inst->src);
	  break;

	case IM_PLEFT:		/* Move pointer left */
	  print_move ('<', inst->src);
	  break;

	case IM_IN:		/* Input */
	  print_input ();
	  break;

	case IM_OUT:		/* Output */
	  print_output ();
	  break;

	case IM_CADD:		/* Cell copy */
	  print_ccpy (inst->dst, inst->src);
	  break;

	case IM_CCLR:		/* Cell clear */
	  print_cclr ();
	  break;
	}

      /* Select next instruction. First from loop, then from next,
         then from ret. */
      if (inst->loop && !returned)
	{
	  print_loop ();
	  inst = inst->loop;
	  returned = 0;
	  indent++;
	}
      else if (inst->next)
	{
	  inst = inst->next;
	  returned = 0;
	}
      else if (inst->ret)
	{
	  print_end ();
	  inst = inst->ret;
	  returned = 1;
	  indent--;
	}
      else
	inst = NULL;
    }

  if (bfthreads)
    {
      fprintf (bfout, "\n");
      fprintf (bfout, "  pthread_exit (NULL);\n");
      fprintf (bfout, "} /* thread %d */\n\n", thread_cnt - 1);
    }
}
Ejemplo n.º 5
0
int main(int argc, const char * argv[])
{
	int fd, fq, kq, nev;
	struct kevent change;
	struct kevent event;

	int len;

	if (argc != 4) {
		fprintf(stderr, "usage: %s printer queue_dir trigger\n", argv[0]);
		return -1;
	}
	printer = strdup(argv[1]);
	queue_dir = strdup(argv[2]);
	trigger = strdup(argv[3]);

	len = snprintf(trigger_cmd, BUFLEN, "%s %s %s", trigger, printer, queue_dir);
	if (len >= BUFLEN - 1) {
		printf("Buffer too small\n");
		return -1;
	}

	len = snprintf(queue_dir_new, BUFLEN, "%s/new", queue_dir);
	if (len >= BUFLEN - 1) {
		printf("Buffer too small\n");
		return -1;
	}

	printer_ready = 0;

	kq = kqueue();
	if (kq == -1)
		perror("kqueue");

	fq = open_and_subscribe(&change, queue_dir_new);

	struct timespec timeout;
	timeout.tv_sec = 5;
	timeout.tv_nsec = 0;

	check_printer_status();
	for (;;) {
		nev = kevent(kq, &change, 1, &event, 1, &timeout);
		if (nev == -1)
			perror("kevent");
		if (nev == 0) { // timeout
			check_printer_status();
		} else if (nev > 0) {
			if (event.fflags & NOTE_DELETE) {
				continue;
			}
			printf("Got event for %d\n", event.ident);
			if (printer_ready) {
				print_loop(printer, queue_dir, trigger);
			}
		}
	}

	close(kq);
	close(fq);
	close(fd);
	return EXIT_SUCCESS;
}
Ejemplo n.º 6
0
void display( void ) {
    int i;

    /*
     * Clear window
     */
    glClearColor( 1.0, 1.0, 1.0, 1.0 );
    glClear( GL_COLOR_BUFFER_BIT );

    /*
     * Set the viewWindow
     */
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity( );
    gluOrtho2D( 0, 300, 0, 300 );

    /*
     * Set the viewport to match the viewWindow
     */
    glViewport( 0, 0, 299, 299 );

    /*
     * first polygon:  entirely within region
     */

    wl = 0;
    clipPolygon( 4, quad1x, quad1y, &wl, wx, wy, 10, 10, 50, 50 );
    glColor3f( 1.0, 0.0, 0.0 );		/* red */
    print_loop( 4, quad1x, quad1y );
    print_poly( wl, wx, wy );

    /*
     * second polygon:  entirely outside region
     */

    wl = 0;
    clipPolygon( 4, quad2x, quad2y, &wl, wx, wy, 10, 10, 50, 50 );
    /* shouldn't draw anything! */
    if( wl > 0 ) {
        glColor3f( 0.0, 1.0, 0.0 );		/* green */
        print_loop( 4, quad2x, quad2y );
        print_poly( wl, wx, wy );
    }

    /*
     * third polygon:  halfway outside on left
     */

    wl = 0;
    clipPolygon( 4, quad3x, quad3y, &wl, wx, wy, 30, 10, 70, 80 );
    glColor3f( 0.0, 0.0, 1.0 );		/* blue */
    print_loop( 4, quad3x, quad3y );
    print_poly( wl, wx, wy );

    /*
     * fourth polygon:  part outside on right
     */

    wl = 0;
    clipPolygon( 4, quad4x, quad4y, &wl, wx, wy, 10, 10, 50, 50 );
    glColor3f( 1.0, 0.0, 1.0 );		/* magenta */
    print_loop( 4, quad4x, quad4y );
    print_poly( wl, wx, wy );

    /*
     * fifth polygon:  enclosing
     */

    wl = 0;
    clipPolygon( 5, pent1x, pent1y, &wl, wx, wy, 90, 20, 100, 30 );
    glColor3f( 0.5, 0.5, 1.0 );		/* reddish-greenish-blue ? */
    print_loop( 5, pent1x, pent1y );
    print_poly( wl, wx, wy );

    /*
     * sixth polygon:  outside on left and bottom
     */

    wl = 0;
    clipPolygon( 5, pent1x, pent1y, &wl, wx, wy, 90, 34, 120, 60 );
    glColor3f( 1.0, 0.5, 1.0 );		/* red-greenish-blue ? */
    print_loop( 5, pent1x, pent1y );
    print_poly( wl, wx, wy );

    /*
     * seventh polygon:  outside on top, right, and bottom
     */

    wl = 0;
    clipPolygon( 7, hept1x, hept1y, &wl, wx, wy, 90, 80, 130, 110 );
    glColor3f( 0.0, 0.0, 0.0 );		/* black */
    print_loop( 7, hept1x, hept1y );
    print_poly( wl, wx, wy );

    /*
     * Flushs OpenGL commands to display
     */
    glFlush();

}