示例#1
0
char	*get_next_line(const int fd)
{
  static char	buffer[NBREAD + 1];
  static int	i;
  t_var	p;

  p = reduc(&p);
  if (i != 0)
    {
      big_reduc(&p, &i, buffer);
      if (buffer[i] == '\n')
	return (p.str = (i++) ? p.str : p.str);
      i = 0;
      return (p.str);
    }
  while (p.curs < BUFF_SIZE)
    {
      if ((p.tmp = read(fd, buffer, NBREAD)) <= 0)
     	return (0);
      buffer[p.tmp] = '\0';
      i = 0;
      big_reduc(&p, &i, buffer);
      if (buffer[i] == '\n')
	return (p.str = (i++) ? p.str : p.str);
    }
  p.str[p.curs] = '\0';
  return (p.str);
}
示例#2
0
void FITSViewer::imageReduction()
{
  FITSProcessCommand *cbc;
  FITSHistogramCommand *hbc;
  QStringList darkFiles, flatFiles, darkflatFiles;
  int darkCombineMode = 0 , flatCombineMode = 0, darkflatCombineMode =0;
  QListViewItem *file;
  
  image->saveTemplateImage();
  ImageReductionDlg irDialog(this);
     
  if (irDialog.exec() == QDialog::Accepted)
  {
    if (irDialog.darkListView->childCount() == 0 && 
        irDialog.flatListView->childCount() == 0)
	{
	 image->destroyTemplateImage();
	 return;
	}
     
    darkCombineMode    = irDialog.darkAverageB->isChecked() ? 0 : 1;
    flatCombineMode    = irDialog.flatAverageB->isChecked() ? 0 : 1;
    darkflatCombineMode= irDialog.darkflatAverageB->isChecked() ? 0 : 1;
     
    file = irDialog.darkListView->firstChild();
    while (file)
    {
      darkFiles << file->text(0);
      file = file->nextSibling();
    }
    
    file = irDialog.flatListView->firstChild();
    while (file)
    {
      flatFiles << file->text(0);
      file = file->nextSibling();
    }
    
    file = irDialog.darkflatListView->firstChild();
    while (file)
    {
      darkflatFiles << file->text(0);
      file = file->nextSibling();
    }
      
      cbc = new FITSProcessCommand(this);
      FITSProcess reduc(this, darkFiles, flatFiles, darkflatFiles, darkCombineMode, flatCombineMode, darkflatCombineMode);
      reduc.reduce();
      history->addCommand(cbc, false);
      calculateStats();
      hbc = new FITSHistogramCommand(this, NULL, FITSImage::FITSLinear, (int) stats.min, (int) stats.max);
      history->addCommand(hbc);
      fitsChange();
  }
  
  image->destroyTemplateImage();

}
示例#3
0
文件: snake.c 项目: solmir/projet42
void		move(t_env *env)
{
	if (env->dir == 0)
	{
		if (env->posy == 0 || env->tab[env->posx][env->posy - 1] > 0)
			ft_error("YOU LOST");
		else
			env->posy--;
	}
	if (env->dir == 2)
	{
		if (env->posy == CNBR - 1 || env->tab[env->posx][env->posy + 1] > 0)
			ft_error("YOU LOST");
		else
			env->posy++;
	}
	if (env->dir == 1)
	{
		if (env->posx == 0 || env->tab[env->posx - 1][env->posy] > 0)
			ft_error("YOU LOST");
		else
			env->posx--;
	}
	if (env->dir == 3)
	{
		if (env->posx == CNBR - 1 || env->tab[env->posx + 1][env->posy] > 0)
			ft_error("YOU LOST");
		else
			env->posx++;
	}
	if (env->tab[env->posx][env->posy] == -1)
	{
		env->val += 2;
		env->bouffe = 0;
	}
	env->tab[env->posx][env->posy] = env->val;
	reduc(env);
}
示例#4
0
int main(){
    scanf("%d",&degree);
    puts(reduc()?"NO":"YES");
}
示例#5
0
文件: READ.CPP 项目: jbailhache/log
DEM read_dem ()
{
int c;
DEM f, a, b, d, x;
int i;
char buf[200];
DEM s;
DEM d1;
int flags1;
DEM used1;
extern DEM used;
loop:
	do c = readchar ();
	while (c==' ' || c=='\t' || c=='\n' || c==0);

	switch (c)
	{
		case 'I': return I;
		case 'K': return K;
		case 'S': return S;
		case 'E': return E;
		case 'F': return If;
		case 'O': return Ord;

		case '-':
			f = read_dem ();
			a = read_dem ();
			return ap (f, a);

		case '/':
			a = read_dem ();
			b = read_dem ();
			return transym (a, b);

                case 'T':
                        a = read_dem ();
                        b = read_dem ();
                        return trans (a, b);

                case 'X':
                        a = read_dem ();
                        return sym (a);

                case '#':
                        a = read_dem ();
                        b = read_dem ();
                        return Axm (a, b);

		case 'i':
			a = read_dem ();
			return defI (a);

		case 'k':
			a = read_dem ();
			b = read_dem ();
			return defK (a, b);

		case 's':
			a = read_dem ();
			b = read_dem ();
                        d = read_dem ();
                        return defS (a, b, d);           

                case ')':
                        a = read_dem ();
                        b = read_dem ();
                        return IfNode (a, b);

                case '1': return Ext1;
                case '2': return Ext2;
                case '3': return Ext3;
                case '4': return Ext4;
                case '5': return Ext5;
                case '6': return Ext6;

		case 'e': return AE;
                case 'f': return EA0;
                        /*
                        a = read_dem ();        
                        return EA (a);
                        */
                case 'm': return MP;
                case 'a': return AI;
                case 'b': return AK;
                case 'c': return AS;
                case 'r': return RPA;

                case '0': return ZeroIsOrd;
                case '+': return SucIsOrd;
                case 'w': return LimIsOrd;
                case 'p': return PredIsOrd;
                case 'n': return StepIsOrd;
                case 'W': return TfI;                

                case '<':
                        a = read_dem ();
                        return left (a);

                case '>':
                        a = read_dem ();
                        return right (a);

                case '\'':
                        a = read_dem ();
                        return rep(a);

		case '%':
/*printf ("*1*");*/
			a = read_dem ();
/*printf ("*2*");*/
                        trace_dem ("read", a);
/*printf ("*3*");*/
                        b = red (a);
/*printf ("*4*");*/
                        trace_dem ("red", b);
                        return b;
			/* return red (a); */
            
                case 'R':
                        a = read_dem ();
                        return red1 (a, 0);

                case '@':
                        a = read_dem ();
                        return reduc (a, 1);
         
		case '~':
			a = read_dem ();
			return reduc (a, 0);

		case '$':
			a = read_dem ();
			return redu (a);

                case 'x':
			a = read_dem ();
			b = read_dem ();
			return ext (a, b);

                case '\\':
			a = read_dem ();
			b = read_dem ();
                        trace_dem ("^(0)", a);
                        trace_dem ("^(1)", b);
                        d = exten (a, b);
                        trace_dem ("^(r)", d);
                        return d;

                case ']':
                	a = read_dem ();
                        b = read_dem ();
                        d = dbextens (a, b);
                        return d;

                case 'l':
                        a = read_dem ();
                        b = read_dem ();
                        return Ext (a, b);
                        /* return Lambda (a, b); */

                case 'L':
                        a = read_dem ();
                        b = read_dem ();
                        return Lambda (a, b);

                case '.':
                        a = read_dem ();
                        return DBLambda (a);

                case '!':
                        a = read_dem ();
                        b = read_dem ();
                        return DB_lambda (a, b);
                        /* return DBLambda (DBname (0, a, b)); */

                case '?':
                        a = read_dem ();
                        b = read_dem ();
                        return DB_Subst (a, b);

                case '_':
                        a = read_dem ();
                        b = read_dem ();
                        d = read_dem ();
                        return Subst (a, b, d);

                case ':':
                        a = read_dem ();
                        b = read_dem ();
                        d = read_dem ();
                        return ap (exten(a,d) ,b);

                case 'V':
                        x = read_dem ();
                        d = read_dem ();
                        a = mk_dem (node(d), 0, NULL,
                                DB_lambda (x, subdem(0,d)),
                                DB_lambda (x, subdem(1,d)),
                                subdem(2,d) == NULL ? NULL :
                                DB_lambda (x, subdem(2,d)),
                                NULL, NULL, NULL);
                        return a;

                case 'A':
                        x = read_dem ();
                        d = read_dem ();
                        a = mk_dem (node(d), 0, NULL,
                                ap (x, subdem(0,d)),
                                ap (x, subdem(1,d)),
                                subdem(2,d) == NULL ? NULL :
                                ap (x, subdem(2,d)),
                                NULL, NULL, NULL);
                        return a;


                case '"':
                        a = read_dem ();
                        /* return NoRed (a); */
                        no_red[nnr++] = a;
                        return a;

                case '|':
                     a = read_dem ();
                     no_red[nnr++] = a;
                     b = read_dem ();
                     return b;

                case 'u':
                	used1 = used;
                    used = read_dem ();
                    a = read_dem ();
                    used = used1;
                    return a;
                    
                case '(':
                        flags1 = flags;
                        i = 0;
                        for (;;)
                        {
                            c = readchar ();
                            if (c == ')')
                                break;
                            buf[i++] = c;
                        }
                        buf[i] = 0;
                        sscanf (buf, "%x", &flags);
                        a = read_dem ();
                        if ((flags & FLAG_PERM) == 0)
                            flags = flags1;
                        return a;

                case ',':
                        a = read_dem ();
                        return step (a);

                case '*':
                        a = read_dem ();
                        return rstep (a);
                
                case '`':
                        a = read_dem ();
                        return list_ap (a, nil);

                case '&':
                        c = readchar ();
                        switch (c)
                        {
                                case '/': return itransym;
                                case 'i': return idefI;
                                case 'k': return idefK;
                                case 's': return idefS;
                                case '<': return ileft;
                                case '>': return iright;
                                case '=': return ieq;
                                case '#': return inode;
                                case '0': return isubdem0;
                                case '1': return isubdem1;
                                case '2': return isubdem2;
                                case '%': return ired;
                                case '$': return iredu;
                                case '\\': return iext;
                                case ',': return istep;
                                case '*': return irstep;
                                default:
                                        fprintf (stderr, "Undefined &%c.\n",
                                                 c);
                                        return I;
                        }
                        break;

                    case '[':
                        /* trace_dem ("read symbol", I); */
                        for (i=0; i<sizeof(buf); i++)
                        {
                            c = readchar();
                            if (c == ']')
                            {
                                buf[i] = 0;
#ifdef TRACE1
                                printf ("buf=<%s>\n", buf);
#endif
                                if (buf[0] >= '0' && buf[0] <= '9')
                                {
#ifdef TRACE
                                    printf ("\nDBVar <%s>", buf);
#endif
                                    d1 = DBVar (atoi(buf));
                                    trace_dem ("", d);
                                    return d1;
                                }
                                s = Sym(buf);
#ifdef TRACE1
                                trace_dem ("read symbol", s);
#endif
                                if (subdem(0,s) == NULL)
                                {
#ifdef TRACE1
                                    trace_dem ("return symbol", s);
#endif
                                    return s;
                                }
                                else
                                {
#ifdef TRACE
                                    trace_dem ("return value of", s);
#endif
                                    return subdem(0,s);
                                }

                            }
                            buf[i] = c;
                        }
                        fprintf (stderr, "Symbol too long\n");
                        return Sym(buf);

		default:
                        return defined_dems[(unsigned char)c];
                        /*
                        printf ("Illegal character 0x%02X\n", c);
			goto loop;
                        */
	}

}
示例#6
0
文件: NLCEI14.C 项目: jbailhache/log
dem _read (memory pm)
{
int c;
dem sd0, sd1, d;
enum node node;
char buf[30];
int i;
dem used1;

debut:
	/* c = getchar (); */
	/* c = fgetc (stdin); */
	c = mygetchar ();
/*
	pm = &_memory;
	_memory.max_dems = MAX_DEMS;
*/
	switch (c)
	{
		case '.':
			exit (0);
		case '-':
			node = node_ap;
		read01:
			sd0 = _read (pm);
			sd1 = _read (pm);
			d = _mkdem (pm, node, 0, NULL, sd0, sd1);
			break;
		case '/':
			node = node_transym;
			goto read01;
		case '%':
			node = node_subst;
			goto read01;
		case '#':
			node = node_axiom;
			goto read01;
		case '\\':
			sd0 = _read (pm);
			d = _mkdem (pm, node_lambda, 0, NULL, sd0, NULL);
			break;
		case '^' :
			sd0 = _read (pm);
			sd1 = _read (pm);
			d = vlambda (sd0, sd1);
			break;
		case ' ' :
		case '\t' :
		case '\n' :
		case '\r' :
		case 0 :
			goto debut;
		case ':' :
			sd0 = _read (pm);
			sd1 = _read (pm);
			sd0->_value = sd1;
			sd1->_name = sd0->_name;
			d = sd1;
			break;
		case '<' :
			sd0 = _read (pm);
			d = lr (0, sd0);
			break;
		case '>' :
			sd0 = _read (pm);
			d = lr (1, sd0);
			break;
		case '$' :
			sd0 = _read (pm);
			d = red (sd0);
			break;
		case '@' :
			sd0 = _read (pm);
			d = reduc (sd0, 1);
			break;
		case '`':
		    used1 = used;
		    used = _read (pm);
		    d = _read (pm);
                    used = used1;
		    break;

		default :
			if ((c >= '0') && (c <= '9'))
				d = _mkdem (pm, node_var, c-'0', NULL, NULL, NULL);
			else
			{
				buf[0] = c;
				for (i=1; ; i++)
				{
					c = mygetchar ();
					if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
					{
						buf[i] = 0;
						break;
					}
					buf[i] = c;
				}
				/*buf[1] = 0;*/
				d = _mkdem (pm, node_symbol, 0, buf, NULL, NULL);
				if (d->_value != NULL)
					d = d->_value;
			}
	}
	return d;
}