Beispiel #1
0
int main(int argc, char *argv[])
{
	/* Performance */
	clock_t begin, end;
	double time_spent;
	begin = clock();

	/* Some variables to initialise the input files read */
	FILE *inputMovieData = fopen(argv[1], "r");
	FILE *outputFile         = fopen(argv[2], "w");

	/* Initialise a global tree of type node */
	node *tree = makedict();

	/* Read in the binary tree with data from argv 1 */
	createBinaryTree(tree, inputMovieData);

	/* Search the tree and write the data to a file specified in argv 2 */
	searchTree(tree, outputFile);

	/* Close the files at the end */
	fclose(inputMovieData);
	fclose(outputFile);

	/* Performance Log */
	end = clock();
	time_spent = (double) (end - begin) / CLOCKS_PER_SEC;
	printf("\nEXECUTION TIME: %.5f seconds\n", time_spent);

	return 0;
}
Beispiel #2
0
int makenapply(const char *key, const char *val) {
    int ret = 1;

    CFMutableDictionaryRef dict = makedict(key, val);
    if(!dict) {
        ERROR("failed to make cf dict\n");
        return ret;
    }

    ret = applydict(dict);

    if (ret) {
        ERROR("applydict failed\n");
    }

    CFRelease(dict);
    return ret;
}
Beispiel #3
0
int main(void)
{
  LBIG memsetup[5] = { 1000, 100, 20, 10, 200 };
  B* startup_dvt;    
  B fromconsoleframe[FRAMEBYTES], *sf;
  P nb, retc,tnb;
  B *sysdict, *userdict, *p;
  int sufd;

  sysop = _sysop;
  syserrc = _syserrc;
  syserrm = _syserrm;

  createfds();

  serialized = TRUE; // no serialize operator

/*----------------- SIGNALS that we wish to handle -------------------*/

/* FPU indigestion is recorded in the numovf flag;
   we do not wish to be killed by it
*/
  numovf = FALSE;
  signal(SIGFPE, SIGFPEhandler);

/* The broken pipe signal is ignored, so it cannot kill us;
   it will pop up in attempts to send on a broken connection
*/
  signal(SIGPIPE, SIG_IGN);

/* We use alarms to time-limit read/write operations on sockets  */
  timeout = FALSE;
  signal(SIGALRM, SIGALRMhandler);

/* The interrupt signal is produced by the control-c key of the
   console keyboard, it triggers the execution of 'abort'
*/
  abortflag = FALSE;
  signal(SIGINT, SIGINThandler);

 /*--------------------- set up the tiny D machine -------------------
   Not so tiny for the dvt, this should be good for most work
*/

  if (makeDmemory(memsetup))
    dm_error(0, "D memory");
  
/*----------------- construct frames for use in execution of D code */
  makename((B*) "error", errorframe);
  ATTR(errorframe) = ACTIVE;

  makename((B*) "fromconsole", fromconsoleframe);
  ATTR(fromconsoleframe) = ACTIVE;

  TAG(FREEvm) = STRING;
  ARRAY_SIZE(FREEvm) = 1024;
  VALUE_PTR(FREEvm) = FREEvm + FRAMEBYTES;
  ATTR(FREEvm) = ACTIVE;
  moveframe(FREEvm, inputframe);
  FREEvm += FRAMEBYTES + 1024;

/* The system dictionary is created in the workspace of the tiny D machine.
   If the operator 'makeVM' is used to create a large D machine, this larger
   machine inherits the system dictionary of the tiny machine. We memorize
   the pointers of the tiny D memory so we can revert to the tiny setup.
*/
  if ((sysdict = makeopdict((B *)sysop, syserrc,  syserrm)) == (B *)(-1L))
    dm_error(0,"Cannot make system dictionary");
  if ((userdict = makedict(memsetup[4])) == (B *)(-1L))
    dm_error(0,"Cannot make user dictionary");
  
/* The first two dictionaries on the dicts are systemdict and userdict;
   they are not removable
*/
  moveframe (sysdict-FRAMEBYTES,FREEdicts); 
  FREEdicts += FRAMEBYTES;
  moveframe (userdict-FRAMEBYTES,FREEdicts); 
  FREEdicts += FRAMEBYTES;

  setupdirs();

  fprintf(stderr, "Startup dir: %s\n", startup_dir);
/*----------- read startup_dvt.d and push on execs ----------*/
  startup_dvt 
    = (B*)strcat(strcpy(malloc(strlen((char*)startup_dir) 
			       + strlen("/startup_dgen.d") + 1),
			startup_dir),
		 "/startup_dgen.d");

  if ((sufd = open((char*)startup_dvt, O_RDONLY)) == -1)
    dm_error(errno,"Opening %s", startup_dvt);
  tnb = 0; sf = FREEvm; p = sf + FRAMEBYTES;
  TAG(sf) = ARRAY | BYTETYPE; ATTR(sf) = READONLY | ACTIVE | PARENT;
  VALUE_BASE(sf) = (P)p;
  
  while (((nb = read(sufd,p,CEILvm-p)) > 0) && (p <= CEILvm)) { 
    tnb += nb; 
    p += nb; 
  }
  if (nb == -1) dm_error(errno,"Reading %s", startup_dvt);
  if (p == CEILvm) dm_error(ENOMEM,"%s > VM", startup_dvt);
  ARRAY_SIZE(sf) = tnb;
  FREEvm += DALIGN(FRAMEBYTES + tnb);
  moveframe(sf,x1);
  FREEexecs = x2;
  
  /*-------------------------- run the D mill --------------------- */
  while (1) {
    switch(retc = exec(1000)) {
      case MORE: continue;
      case DONE:     
	moveframe(fromconsoleframe, x1); 
	FREEexecs=x2; 
	continue;
      case ABORT:
	printf("Failure...\n");
	exitval = ((UL32) EXIT_FAILURE) & 0xFF;
	die();
      case QUIT: case TERM: 
	printf("Success..\n"); 
	die();
      default: break;
    }

/*----------------------- error handler ---------------------------*/

    makeerror(retc, errsource);
  };
} /* of main */