C++ chop函数代码示例

void AdvancedSearchState::SetSizeFilter(Ui::MainWindow* window, SearchParameter& parameter)
{
	QString option = window->sizeComboBox->currentText();
	bool sizeIgnored = option.indexOf("Ignore") != -1;

	qint64 lowerSize = 0,
			 upperSize = 0;

	if (sizeIgnored == false)
	{
		bool between = option.indexOf("Between") != -1;
		bool larger  = option.indexOf("Larger")  != -1;
		bool smaller = option.indexOf("Smaller") != -1;

		if (larger)
			lowerSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
							chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'
		if (smaller)
			upperSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
							chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'
		if (between)
		{
			lowerSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit->text()).arg(
							chop(window->sizeUnitsComboBox->currentText(), 4))); // chop 'ytes'

			upperSize = units2bytes(QString("%1 %2").arg(window->sizeLineEdit2->text()).arg(
							chop(window->sizeUnitsComboBox2->currentText(), 4)));
		}
	}
	parameter.phaseOneParam->SetSizeLowerBound(lowerSize);
	parameter.phaseOneParam->SetSizeUpperBound(upperSize);
}

int chop(int target, int* array, size_t size)
{
    // handle empty array
    if(size == 0) {
        return -1;
    } else if(size == 1) { // single element array - check value
        if(array[0] == target) {
            return 0;
        } else {
            return -1;
        }
    } else { // wider array are split into two parts and we search in the part in that the element should be
        int split = (size / 2);

        if(target < array[split]) {
            return chop(target, array, split);
        } else {
            int res;

            if((res = chop(target, array + split, size - split)) != -1) {
                return split + res;    
            } else {
                return res;
            }
            
        }
    }
}

void load_high_scores() {
	FILE *hiscores_file = fopen(options.full_path("hiscores"), "r");

	num_high_scores = 0;

	if (!hiscores_file) {
		return;
	}

	char line[256];
	char *not_empty;
	while (!feof(hiscores_file)) {
		// Get name
		not_empty = fgets(line, 256, hiscores_file);
		chop(line);
		if (line[0] == '\0' || !not_empty) break;
		strcpy(high_scores[num_high_scores].name, line);

		// Get score
		not_empty = fgets(line, 256, hiscores_file);
		chop(line);
		if (line[0] == '\0' || !not_empty) break;

		s32 the_score;
		intval(line, &the_score);
		
		high_scores[num_high_scores].score = the_score;

		num_high_scores++;
	}

	fclose(hiscores_file);
}

void netchanNeedop(BotNet *source, char *rest)
{
	BotNet	*bn;
	BotInfo	*binfo;
	char	*channel;
	int	guid;

	guid = a2i(chop(&rest));
	channel = chop(&rest);
	if (errno || guid < 1 || !channel)
		return;

	botnet_relay(source,"CO%i %s\n",guid,channel);

	for(bn=botnetlist;bn;bn=bn->next)
	{
		if (bn->status != BN_LINKED)
			continue;
		for(binfo=bn->botinfo;binfo;binfo=binfo->next)
		{
			if (binfo->guid == guid)
				check_botinfo(binfo,channel);
		}
        }
}

int read_seenlist_callback(char *rest)
{
	char	*nick,*uh,*pa,*pb;
	time_t	when;
	int	t;

	nick = chop(&rest);
	uh   = chop(&rest);

	when = a2i(chop(&rest)); /* seen time, a2i handles NULL */
	if (errno)
		return(FALSE);

	t    = a2i(chop(&rest)); /* seen type, a2i handles NULL */
	if (errno)
		return(FALSE);

	pa = chop(&rest);
	pb = rest;

	if ((now - when) < (SEEN_TIME * 86400))
	{
		/* if (pa && !*pa)
			pa = NULL; chop() doesnt return empty strings */
		if (!*pb)
			pb = NULL;
		make_seen(nick,uh,pa,pb,when,t);
	}
	return(FALSE);
}

///Calculate Exp[I*m]
LaGenMatComplex snake::math::expm2(LaGenMatDouble &m)
{
  //std::cout<<m<<std::endl;
  int dim = m.size(0);
  LaGenMatComplex r(dim,dim);
  LaGenMatDouble eigvec(dim,dim);
  LaGenMatComplex eigvecC(dim,dim);
  LaVectorDouble eigval(dim);
  LaVectorComplex eigvalim(dim);
  eigvec = m;
  snake::math::SSMED(eigvec.addr(),dim,eigval.addr());

  for(int i = 0;i<dim;i++)
    eigvalim(i) = LaComplex(cos(eigval(i)),sin(eigval(i)));
  LaGenMatComplex temp(dim,dim);
  temp = LaComplex(0,0);
  for(int i = 0;i<dim;i++)
    temp(i,i) = eigvalim(i);

  chop(temp,1e-15);
  //std::cout<<temp<<std::endl;
  eigvecC = eigvec.to_LaGenMatComplex();
  LaGenMatComplex tempx(dim,dim);
  Blas_Mat_Mat_Trans_Mult(temp,eigvecC,tempx);
  Blas_Mat_Mat_Mult(eigvecC,tempx,r);
  chop(r,1e-15);
  return r;
}

		TEMP_PAR
		typename NUM_SYS::DigitSet 
		  NUM_SYS::getDigits(const Vector<INT_TYPE>& z) const
		{
			bool finished = false;
			IVector v = vector_traits_int::copy(z);
			DigitSet digits;
      digits.reserve(20);
			digits.push_back(v);
			v = chop(v);
			while(!finished)
			{
				if( find_if(digits.begin(), digits.end(), DigitFinder(v)) != 
						digits.end())
				{
					finished = true;
				}
				else
				{
					digits.push_back(v);
					v = chop(v);
				}
			}
			return digits;
		}

static void dirtodots(char *path, unsigned maxlen)
{
	char *first_slash, *end_slash;

	first_slash = strchr(path, '/');

	if(!first_slash) {
		chop(path, maxlen);
		return;
	}

	if(strncmp(first_slash+1, "...", 3) == 0) {
		end_slash = strchr(first_slash+5, '/');
	} else
		end_slash = strchr(first_slash+1, '/');

	if(!end_slash) {
		chop(path, maxlen);
		return;
	}

	if(end_slash - first_slash < 4) /* /fu/ */
		strpush(first_slash+1, 4 - (end_slash - first_slash));
	else /* /foobar/ */
		strcpy(first_slash + 4, end_slash);
	strncpy(first_slash+1, "...", 3);
}

void main() {
  allegrosetup(scrwid,scrhei);
  makesplitpalette(&redtowhitepalette,&greentowhitepalette);
  PPsetup(scrwid,scrhei,4);
  JBmp j=JBmp(scrwid,scrhei);
  j.clear();
  List<Part> ps=List<Part>();
  for (int i=1;i<=10;i++) {
    Part p;
    newpart(&p);
    ps+p;
  }
  int frame=0;
  do {
    for (int i=1;i<=ps.len;i++) {
      Part *p=ps.p2num(i);
      int sx,sy;
      PPgetscrpos(p->pos,&sx,&sy);
      int sxb,syb;
      PPgetscrpos(p->pos+V3d(p->rad,0,0),&sxb,&syb);
      float rad=sqrt(mysquare(sx-sxb)+mysquare(sy-syb));
      j.filledcircle(sx,sy,rad,p->inc);
//      j.filledcirclenodarker(sx,sy,rad/3,p->inc);
    }
    for (int x=0;x<scrwid;x++)
      for (int y=0;y<scrhei;y++) {
        int k=j.bmp[y][x];
        if (k==128)
          j.bmp[y][x]=0;
        if (k<128)
          j.bmp[y][x]=chop(k-4,0,128);
        else
          j.bmp[y][x]=128+chop(k-4-128,0,128);
      }
    j.writetoscreen();
    Matrix m,n;
    V3d rotaxis=V3d::rotate(V3d(0,1,0),V3d(0,0,1),pi/4.0*sin(2*pi*frame/4000));
    m.makerotation(rotaxis,pi/1000.0);
    n.makerotation(rotaxis,-pi/1000.0);
    for (int i=1;i<=ps.len;i++) {
      Part *p=ps.p2num(i);
      if (p->sgn>0)
        p->pos=m*p->pos;
      else
        p->pos=n*p->pos;
      p->pos=p->pos+V3d(0,0,-0.03);
      if (p->pos.z<-4 || max(myabs(p->pos.x),myabs(p->pos.y))>2)
        newpart(p);
    }
    frame++;
  } while (!key[KEY_ESC]);
}

static void load_dsc()
{
    s_objtab.clear();
    Slice dsc = read_file("grafix/corri01.dsc");
    chop_until(dsc, 0); // skip until first 0 byte

    while (dsc.len()) {
        // header:
        //   void *img[3];
        //   U8 x, y;
        //   U8 unk;
        //   U8 cursorType, imgType;
        Slice header = chop(dsc, 17);
        Str name = to_string(chop_until(dsc, '\r'));
        Slice script = chop_until(dsc, 0);

		// fix up script
		for (U32 i=0; i < script.len(); i++)
			if (script[i] == '^')
				script[i] = '\n';

        //print_hex(Str::fmt("%2d %8s: ", s_objtab.size(), name), header, 17);

        ObjectDesc d;
        d.script = script;
        d.gfx_name = name;
        d.x = header[12];
        d.y = header[13];
        d.flipX = header[14];
        d.cursor = header[15];
        // imgtype = header[16]
        s_objtab.push_back(d);
    }
}

void usernameHandler(char *buffer, int sock) //handles username requests
{
    grabContents(buffer); //get the actual message minus command
    chop(buffer); //chop off anything extraneous
    
    int x = 0;
    
    for (x = 0; x < MAX_USERS; x++) //check username with all users and return bad if not found
    {
        if (strcmp(users[x].username, buffer) == 0)
        {
            char tempBuffer[MAX_MESSAGE_SIZE];
            sprintf(tempBuffer, " %dError: username '%s' all ready taken\n", NAME_TAKEN, buffer);
            writeMessageDefined(sock, tempBuffer);
            return;
        }
    }
    
    //if good return a good call and establish the username
    sprintf(users[sock].username, "%s", buffer);
    printf("\nUsername established: %s\n", users[sock].username);  
    
    zeroBuffer(buffer);
    sprintf(buffer, "Server: Username established '%s'\n", users[sock].username);
    
    writeMessageDefined(sock, buffer);
}

void do_rkicksay(COMMAND_ARGS)
{
	/*
	 *  on_msg checks: CARGS
	 */
	KickSay *kick;
	char	*channel;

	channel = chop(&rest);	/* cant be NULL (CARGS) */
	if (!ischannel(channel) && *channel != '*')
		goto usage;

	if (!*rest)
		goto usage;

	if (!(kick = find_kicksay(rest,channel)))
	{
		to_user(from,"I'm not kicking on that");
		return;
	}
	to_user(from,"No longer kicking on %s",kick->mask);
	remove_kicksay(kick);
	current->ul_save++;
	return;
usage:
	usage(from);	/* usage for CurrentCmd->name */
}

int main(int argc,char**argv)
{
  FILE *fi,*fo;
  char buf[256];
  char *st;

  if(argc==2) {
    fi=fopen(argv[1],"r");
    strcpy(buf,argv[1]);
    //strcpy(buf+strlen(buf)-4,".log"); // ".xxx"->".log"
    strcpy(buf+strlen(buf)-4,"_smile"); // ".xxx" -> "_smile.xxx"
    strcpy(buf+strlen(buf)  ,argv[1]+strlen(argv[1])-4);
    fo=fopen(buf,"w");

    while(st=fgets(buf,sizeof(buf),fi)){
      chop(st);
      fprintf(fo,"%s(^^)/~\n",st);
    }

    fclose(fi);
    fclose(fo);
    return 0;

  } else {
    printf("USAGE: %s filename",argv[0]);
    return 0;
  }
}

void CIMainWindow::startBuilding()
{
    QString cmd(mCompilerPath);
    mProcBuild = new QProcess(this);

    if (mCompilerParamList.size() > 0)
    {
        QString str = mCompilerParamList[mBuildingCount++];

        // TEST ONLY!!!
        str.remove(0, 1);
        str = "\"D:/!GEMS8/" + str;

        QString arg_sln = str.section(' ', 0, 0);
        auto arg_build = str.section(' ', 1, 1);
        auto arg_build_type = str.section(' ', 2);
        arg_sln.remove(0, 1);
        arg_sln.chop(1);
        arg_build_type.remove(0, 1);
        arg_build_type.chop(1);
        QStringList args;
        args << arg_sln << arg_build << arg_build_type;
        mProcBuild->setProgram(cmd);
        mProcBuild->setArguments(args);
        mProcBuild->start();
    }

    QObject::connect(mProcBuild, SIGNAL(readyReadStandardOutput()), this, SLOT(on_readyReadBuildingStandardOutput()));
    QObject::connect(mProcBuild, SIGNAL(finished(int)), this, SLOT(buildAnotherSolutionOrDone()));
}

char * convert_flags_to_str(unsigned long flags)
{
unsigned int i;
unsigned long p;
static char buffer[290];
	*buffer = 0;
	for (i = 0, p = 1; strflags[i]; i++, p <<= 1)
	{
		if (flags & p)
		{
			strmcat(buffer, strflags[i], 280);
			strmcat(buffer, ",", 280);
		}
	}
	for (i = 0, p = PROT_REOP; protflags[i]; i++, p <<= 1)
	{
		if (flags & p)
		{
			strmcat(buffer, protflags[i], 280);
			strmcat(buffer, ",", 280);
		}
	}
	if (*buffer)
		chop(buffer, 1);
	return buffer;
}