Exemple #1
0
Face*
dirface(char *dir, char *num)
{
	Face *f;
	char *from, *date;
	char buf[1024], pwd[1024], *info, *p, *digest;
	int n, fd;
	ulong len;

	/*
	 * loadmbox leaves us in maildir, so we needn't
	 * walk /mail/fs/mbox for each face; this makes startup
	 * a fair bit quicker.
	 */
	if(getwd(pwd, sizeof pwd) != nil && strcmp(pwd, dir) == 0)
		sprint(buf, "%s/info", num);
	else
		sprint(buf, "%s/%s/info", dir, num);
	len = dirlen(buf);
	if(len <= 0)
		return nil;
	fd = open(buf, OREAD);
	if(fd < 0)
		return nil;
	info = emalloc(len+1);
	n = readn(fd, info, len);
	close(fd);
	if(n < 0){
		free(info);
		return nil;
	}
	info[n] = '\0';
	f = emalloc(sizeof(Face));
	from = iline(info, &p);	/* from */
	iline(p, &p);	/* to */
	iline(p, &p);	/* cc */
	iline(p, &p);	/* replyto */
	date = iline(p, &p);	/* date */
	setname(f, estrdup(from));
	f->time = parsedate(date);
	f->tm = *localtime(f->time);
	sprint(buf, "%s/%s", dir, num);
	f->str[Sshow] = estrdup(buf);
	iline(p, &p);	/* subject */
	iline(p, &p);	/* mime content type */
	iline(p, &p);	/* mime disposition */
	iline(p, &p);	/* filename */
	digest = iline(p, &p);	/* digest */
	f->str[Sdigest] = estrdup(digest);
	free(info);
	return f;
}
Exemple #2
0
/**
 * Load a dataset stored in a file.
 *
 * @param filename Dataset filename
 */
bool Dataset::loadDataset(const string& nomefile)
{
	int version; 
	string line, dummy;
	ifstream infile(nomefile.c_str());

	if(!infile.is_open()) {
		cout << "[Error] Unable to open the dataset file" << endl;
		return false;
	}
	else {
		trainings.clear();
		
		// Version
		getline(infile,line); // First line is WiiC log version
		if(line.find("WiiC") == string::npos) {
			cout << "[Error] Bad log format." << endl;
			return false;
		}
		istringstream iline(line);
		iline >> dummy >> version;
		if(version > WIIC_LOG_VERSION) {
			cout << "[Error] Unsupported WiiC log version." << endl;
			return false;
		}
		getline(infile,line); // Date (we should load this as well...)
		
		// For each training
		int counter = 0;
		while(!infile.eof()) {
			getline(infile,line);
			istringstream iline(line);
			string cmd; 
			unsigned long ts;
			iline >> cmd >> ts;
			if(cmd == "START") {
				// Each training is inserted in the training vector	
				trainings.push_back(new Training());
				trainings[counter]->setTimestampFromMidnight(ts);
				if(!(trainings[counter++]->loadTraining(infile))) {
					cout << "[Error] Unable to load a training in the dataset" << endl ;
					return false;
				}
			}
		}
	}
	infile.close();
	loaded = true;
	
	return loaded;
}
Exemple #3
0
int main(int argC, char* argv[]) {
  if(argc < 1) {
    cerr << "need training data" << endl;
    exit(1);
  }

  corpus trainingData;
  {
    ifstream datafile(argv[1]);
    char line[255];
    while(datafile.getline(line,255)) {
      sentence s;
      string word;
      istrstream iline(line,strlen(line));
      while(iline >> word) {
	s.push_back(word);
      }
      if(s.size() > 0)
	trainingData.push_back(s);
    } 
  }

  cerr << "reading cnf grammar..." << endl;
  PCFG aPCFG;
  cin >> aPCFG;
  aPCFG.train(trainingData);
  cout << aPCFG;
}
Exemple #4
0
/*=============================================+
 * vprog_error -- Report a run time program error
 *  node:        current parsed node
 *  fmt, args:   printf style message
 *  ...:    printf style varargs
 * Prints error to the stdout-style curses window
 * and to the report log (if one was specified in config file)
 * Always includes line number of node, if available
 * Only includes file name if not same as previous error
 * Returns static buffer with one-line description
 *============================================*/
static STRING
vprog_error (PNODE node, STRING fmt, va_list args)
{
	INT num;
	STRING rptfile;
	ZSTR zstr=zs_newn(256);
	static char msgbuff[100];
	if (rpt_cancelled)
		return _("Report cancelled");
	rptfile = getlloptstr("ReportLog", NULL);
	if (node) {
		STRING fname = irptinfo(node)->fullpath;
		INT lineno = iline(node)+1;
		/* Display filename if not same as last error */
		if (!eqstr(vprog_prevfile, fname)) {
			llstrsets(vprog_prevfile, sizeof(vprog_prevfile), uu8, fname);
			zs_apps(zstr, _("Report file: "));
			zs_apps(zstr, fname);
			zs_appc(zstr, '\n');
			vprog_prevline = -1; /* force line number display */
		}
		/* Display line number if not same as last error */
		if (vprog_prevline != lineno) {
			vprog_prevline = lineno;
			if (progparsing)
				zs_appf(zstr, _("Parsing Error at line %d: "), lineno);
			else
				zs_appf(zstr, _("Runtime Error at line %d: "), lineno);
		}
	} else {
		zs_apps(zstr, _("Aborting: "));
	}
	zs_appvf(zstr, fmt, args);
	llwprintf("\n");
	llwprintf(zs_str(zstr));
	++progerror;
	/* if user specified a report error log (in config file) */
	if (rptfile && rptfile[0]) {
		FILE * fp = fopen(rptfile, LLAPPENDTEXT);
		if (fp) {
			if (progerror == 1) {
				LLDATE creation;
				get_current_lldate(&creation);
				fprintf(fp, "\n%s\n", creation.datestr);
			}
			fprintf(fp, "%s", zs_str(zstr));
			fprintf(fp, "\n");
			fclose(fp);
		}
	}
	if ((num = getlloptint("PerErrorDelay", 0)))
		sleep(num);
	zs_free(&zstr);
	return msgbuff;
}
Exemple #5
0
/*==========================================+
 * evaluate_func -- Evaluate builtin function
 *=========================================*/
PVALUE
evaluate_func (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
    PVALUE val;

    *eflg = FALSE;
    if (prog_trace)
        trace_outl("evaluate_func called: %d: %s",
                   iline(node)+1, iname(node));
    val = (*(PFUNC)ifunc(node))(node, stab, eflg);
    return val;
}
Exemple #6
0
static void
loop()
{
	int timediff;
	struct tbuf *tp;

	if (wb.ut_line[0] == '\0')	/* It's an init admin process */
		return;			/* no connect accounting data here */
	switch (wb.ut_type) {
	case OLD_TIME:
		datetime = wb.ut_xtime;
		return;
	case NEW_TIME:
		if (datetime == 0)
			return;
		timediff = wb.ut_xtime - datetime;
		for (tp = tbuf; tp <= &tbuf[tsize]; tp++)
			tp->ttime += timediff;
		datetime = 0;
		ndates++;
		return;
	case DOWN_TIME:
		return;
	case BOOT_TIME:
		upall();
	case ACCOUNTING:
	case RUN_LVL:
		lastime = wb.ut_xtime;
		bootshut();
		return;
	case USER_PROCESS:
	case LOGIN_PROCESS:
	case INIT_PROCESS:
	case DEAD_PROCESS:	/* WHCC mod 3/86  */
		update(&tbuf[iline()]);
		return;
	case EMPTY:
		return;
	default:
		cftime(time_buf, DATE_FMT, &wb.ut_xtime);
		fprintf(stderr, "acctcon: invalid type %d for %s %s %s",
			wb.ut_type,
			wb.ut_name,
			wb.ut_line,
			time_buf);
	}
}
Exemple #7
0
Face*
dirface(char *dir, char *num)
{
	Face *f;
	char buf[1024],  *info, *p, *t, *s;
	int n;
	ulong len;
	CFid *fid;

	sprint(buf, "%s/%s/info", dir, num);
	len = fsdirlen(mailfs, buf);
	if(len <= 0)
		return nil;
	fid = fsopen(mailfs, buf, OREAD);
	if(fid == nil)
		return nil;
	info = emalloc(len+1);
	n = fsreadn(fid, info, len);
	fsclose(fid);
	if(n < 0){
		free(info);
		return nil;
	}
	info[n] = '\0';
	f = emalloc(sizeof(Face));
	for(p=info; (s=iline(p, &p)) != nil; ){
		t = strchr(s, ' ');
		if(t == nil)
			continue;
		*t++ = 0;
		if(strcmp(s, "unixdate") == 0){
			f->time = atoi(t);
			f->tm = *localtime(f->time);
		}
		else if(strcmp(s, "from") == 0)
			setname(f, t);
		else if(strcmp(s, "digest") == 0)
			f->str[Sdigest] = estrdup(t);
	}
	sprint(buf, "%s/%s", dir, num);
	f->str[Sshow] = estrdup(buf);
	free(info);
	return f;
}
int RF2::run(istream& in)
{
    const streamsize ilinelen = 1024;
    scoped_array<char> iline(new char[ilinelen]);
    int cnt = 0;
    dmlif::DMLIF dmlif(fSessionID, fTflg, fDflg, fVflg);

    for (;;)
    {
        dmlif.rf2Start(fSchema);

        for (int i = 0; i < fPack; i++)
        {
            in.getline(iline.get(), ilinelen);

            if (in.eof())
                break;

            typedef char_separator<char> cs;
            typedef tokenizer<cs> tk;
            cs sep("|");
            tk tok(string(iline.get()), sep);
            tk::iterator iter = tok.begin();
            idbassert(iter != tok.end());
            string keystr = *iter;
            ++iter;
            //idbassert(iter == tok.end());
            int64_t okey = strtol(keystr.c_str(), 0, 0);
            dmlif.rf2Add(okey);
        }

        dmlif.rf2Send();
        cnt++;

        if ((cnt % fIntvl) == 0)
            dmlif.sendOne("COMMIT;");

        if (in.eof())
            break;
    }

    dmlif.sendOne("COMMIT;");
    return 0;
}
Exemple #9
0
Fichier : t.c Projet : shank8/CS460
int body()
{
   char c, CR, buf[64];
   while(1){
      printf("=======================================\n");
      printQueue(readyQueue);      

      printf("proc %d %s in Kmode\n", running->pid, running->name);
      printf("input a command (s|f|u|q|i|o) : ");
      c=getc(); putc(c); CR=getc(); putc(CR);
      switch(c){
          case 's' : tswitch(); break;
          case 'u' : printf("\nProc %d ready to go U mode\n", running->pid);
                     goUmode(); break;
          case 'f':  fork();  break;
          case 'q' : kexit();   break;
          case 'i' : iline();   break;
          case 'o' : oline();   break;
      }
   }
}
Exemple #10
0
/*=============================+
 * evaluate -- Generic evaluator
 *============================*/
PVALUE
evaluate (PNODE node, SYMTAB stab, BOOLEAN *eflg)
{
    if (prog_trace) {
        trace_out("%d: ", iline(node)+1);
        trace_pnode(node);
        trace_endl();
    }
    if (iistype(node, IIDENT))
        return evaluate_iden(node, stab, eflg);
    if (iistype(node, IBCALL))
        return evaluate_func(node, stab, eflg);
    if (iistype(node, IFCALL))
        return evaluate_ufunc(node, stab, eflg);
    *eflg = FALSE;
    if (iistype(node, IICONS))
        return copy_pvalue(ivalue(node));
    if (iistype(node, ISCONS))
        return copy_pvalue(ivalue(node));
    if (iistype(node, IFCONS))
        return copy_pvalue(ivalue(node));
    *eflg = TRUE;
    return NULL;
}
Exemple #11
0
/**
 * Load dataset from a file into a class Dataset
 */
void Dataset::loadDataset(const string& nomefile)
{
	int size; 
	string line;
	ifstream infile(nomefile.c_str());

	if(!infile.is_open()) {
		cout<<"[Error] Unable to open the dataset file"<<endl;
	}
	else {
		trainings.clear();
		getline(infile,line);
		istringstream iline(line);
		iline >> size;
		
		for(int i = 0 ; i < size ; i++) {
			// Each training is inserted in the training vector	
			trainings.push_back(new Training());	
			// Each training is filled with its relative values (polymorphism)
			trainings[i]->loadTraining(infile);
		}
	}
	infile.close();
}
Exemple #12
0
void
cont(int x0, int y0)
{
	iline(xnow,ynow,xconv(xsc(x0)),yconv(ysc(y0)));
	return;
}
Exemple #13
0
void
line(int x0, int y0, int x1, int y1)
{
	iline(xconv(xsc(x0)),yconv(ysc(y0)),xconv(xsc(x1)),yconv(ysc(y1)));
		return;
}
Exemple #14
0
cont(x0,y0){
	iline(xnow,ynow,xconv(xsc(x0)),yconv(ysc(y0)));
	return;
}
Exemple #15
0
line(x0,y0,x1,y1){
	iline(xconv(xsc(x0)),yconv(ysc(y0)),xconv(xsc(x1)),yconv(ysc(y1)));
		return;
}