Exemple #1
0
/**
 * Find a boolean option (like quiet,noapic,nosmp....)
 *
 * @cmdline: the cmdline string
 * @option: option string to look for
 *
 * Returns the position of that @option (starts counting with 1)
 * or 0 on not found.
 */
int cmdline_find_option_bool(const char *cmdline, const char *option)
{
	char c;
	int len, pos = 0, wstart = 0;
	const char *opptr = NULL;
	enum {
		st_wordstart = 0,	/* Start of word/after whitespace */
		st_wordcmp,	/* Comparing this word */
		st_wordskip,	/* Miscompare, skip */
	} state = st_wordstart;

	if (!cmdline)
		return -1;      /* No command line */

	len = min_t(int, strlen(cmdline), COMMAND_LINE_SIZE);
	if (!len)
		return 0;

	while (len--) {
		c = *(char *)cmdline++;
		pos++;

		switch (state) {
		case st_wordstart:
			if (!c)
				return 0;
			else if (myisspace(c))
				break;

			state = st_wordcmp;
			opptr = option;
			wstart = pos;
			/* fall through */

		case st_wordcmp:
			if (!*opptr)
				if (!c || myisspace(c))
					return wstart;
				else
					state = st_wordskip;
			else if (!c)
				return 0;
			else if (c != *opptr++)
				state = st_wordskip;
			else if (!len)		/* last word and is matching */
				return wstart;
			break;

		case st_wordskip:
			if (!c)
				return 0;
			else if (myisspace(c))
				state = st_wordstart;
			break;
		}
	}

	return 0;	/* Buffer overrun */
}
Exemple #2
0
int cmdline_find_option_bool(const char *option)
{
	u32 cmdline_ptr = boot_params.hdr.cmd_line_ptr;
	addr_t cptr;
	char c;
	int pos = 0, wstart = 0;
	const char *opptr = NULL;
	enum {
		st_wordstart,	
		st_wordcmp,	
		st_wordskip,	
	} state = st_wordstart;

	if (!cmdline_ptr || cmdline_ptr >= 0x100000)
		return -1;	

	cptr = cmdline_ptr & 0xf;
	set_fs(cmdline_ptr >> 4);

	while (cptr < 0x10000) {
		c = rdfs8(cptr++);
		pos++;

		switch (state) {
		case st_wordstart:
			if (!c)
				return 0;
			else if (myisspace(c))
				break;

			state = st_wordcmp;
			opptr = option;
			wstart = pos;
			

		case st_wordcmp:
			if (!*opptr)
				if (!c || myisspace(c))
					return wstart;
				else
					state = st_wordskip;
			else if (!c)
				return 0;
			else if (c != *opptr++)
				state = st_wordskip;
			break;

		case st_wordskip:
			if (!c)
				return 0;
			else if (myisspace(c))
				state = st_wordstart;
			break;
		}
	}

	return 0;	
}
Exemple #3
0
/*
 * Find a boolean option (like quiet,noapic,nosmp....)
 *
 * Returns the position of that option (starts counting with 1)
 * or 0 on not found
 */
int __cmdline_find_option_bool(u32 cmdline_ptr, const char *option)
{
	addr_t cptr;
	char c;
	int pos = 0, wstart = 0;
	const char *opptr = NULL;
	enum {
		st_wordstart,	/* Start of word/after whitespace */
		st_wordcmp,	/* Comparing this word */
		st_wordskip,	/* Miscompare, skip */
	} state = st_wordstart;

	if (!cmdline_ptr || cmdline_ptr >= 0x100000)
		return -1;	/* No command line, or inaccessible */

	cptr = cmdline_ptr & 0xf;
	set_fs(cmdline_ptr >> 4);

	while (cptr < 0x10000) {
		c = rdfs8(cptr++);
		pos++;

		switch (state) {
		case st_wordstart:
			if (!c)
				return 0;
			else if (myisspace(c))
				break;

			state = st_wordcmp;
			opptr = option;
			wstart = pos;
			/* fall through */

		case st_wordcmp:
			if (!*opptr)
				if (!c || myisspace(c))
					return wstart;
				else
					state = st_wordskip;
			else if (!c)
				return 0;
			else if (c != *opptr++)
				state = st_wordskip;
			break;

		case st_wordskip:
			if (!c)
				return 0;
			else if (myisspace(c))
				state = st_wordstart;
			break;
		}
	}

	return 0;	/* Buffer overrun */
}
Exemple #4
0
/* mostly duplicated from cvs/src/ignore.c */
static void ign_add(const char* ign, std::vector<std::string>& ignlist)
{
   if (!ign || !*ign)
      return;

   int ign_hold = ignlist.empty() ? -1 : (int) ignlist.size();
   bool escape = false;

   for (; *ign; ign++)
   {
      /* ignore whitespace before the token */
      if (myisspace(*ign))
         continue;

      /*
       * if we find a single character !, we must re-set the ignore list
       * (saving it if necessary).  We also catch * as a special case in a
       * global ignore file as an optimization
       */
      char next = *(ign+1);
      if ((!*(ign+1) || myisspace(*(ign+1))) && (*ign == '!' || *ign == '*'))
      {
         /* temporarily reset the ignore list */
         if (ign_hold >= 0)
         {
            ignlist.erase(ignlist.begin(), ignlist.begin() + ign_hold);
            ign_hold = -1;
         }
         continue;
      }

      // Find the end of this token, treating "\ " as an escaped space
      const char* mark;
      escape = false;
      for (mark = ign; *mark && (escape || !myisspace(*mark)); mark++)
      {
         escape = false;
         if (*mark == '\\')
            escape = true;
      }

      std::string token(ign, mark-ign);
      FindAndReplace<std::string>(token, "\\\\", "\\");
      ignlist.push_back(token);

      if (*mark)
         ign = mark;
      else
         ign = mark - 1;
   }
}
Exemple #5
0
int picolParseSep(picolParser *p) {
    p->start = p->p;
    while(myisspace(*p->p) || (*p->p=='\\' && *(p->p+1)=='\n')) {
        p->p++; p->len--;
    }
    RETURN_PARSED(PT_SEP);
}
Exemple #6
0
int myatoi(char s[])
{
	int i;
	int sign = 1;
	int num = 0;
	for(i = 0; myisspace(s[i]); i++)
		;
	if(s[i] == '-')
	{
		sign = -1;
		i++;
	}
	else if(s[i] == '+')
	{
		sign = 1;
		i++;
	}
	for(; s[i] != '\0'; i++)
	{
		if(myisdigit(s[i]))
			num = num*10 + (s[i] - '0');
		else 
		{
			printf("unexpect token \'%c\'\n",s[i]);
			return 0;
		}
		printf("%d: %d\n",i,num);
	}
	return sign * num;
}
Exemple #7
0
int Formula::eval_mul(char *&s, Args *args, bool *vars) const
{
	int left = eval_atom(s, args, vars);
	while (*s)
	{
		if (myisspace(*s))
		{
			++s;
		} else
		if(*s == '*')
		{
			left *= eval_atom(++s, args, vars);
		} else
		if(*s == '/')
		{
			if (int right = eval_atom(++s, args, vars))
				left /= right;
		} else
		if(*s == '%')
		{
			if (int right = eval_atom(++s, args, vars))
				left %= right;
		} else
		{
			break;
		}
	}
	return left;
}
Exemple #8
0
int Formula::eval_neq(char *&s, Args *args, bool *vars) const
{
	int left = eval_sum(s, args, vars);
	while (*s)
	{
		if (myisspace(*s))
		{
			++s;
		} else
		if (*s == '<')
		{
			// this is needed due to side effects caused by min() macro...
			int tmp = eval_sum(++s, args, vars);
			left = min(left, tmp);
		} else
		if (*s == '>')
		{
			// this is needed due to side effects caused by max() macro...
			int tmp = eval_sum(++s, args, vars);
			left = max(left, tmp);
		} else
		{
			break;
		}
	}
	return left;
}
Exemple #9
0
int Formula::eval_atom(char *&s, Args *args, bool *vars) const
{
	while (*s)
	{
		if (myisspace(*s))
		{
			++s;
		} else
		if (*s == '(')
		{
			int res = eval_neq(++s, args, vars);
			if (*s == ')')
				++s;
			return res;
		} else
		if ((*s == '+') || (*s == '-'))
		{
			int sign = 1;
			if (*s == '-')
				sign = -1;
			return sign * eval_neq(++s, args, vars);
		} else
		if (*s == '!')
		{
			return !eval_neq(++s, args, vars);
		} else
		if ((*s >= '0') && (*s <= '9'))
		{
			int res = 0;
			while ((*s >= '0') && (*s <= '9'))
				res = res * 10 + *s++ - '0';
			return res;
		} else
		{
			if (!args)
				return 0;
			char buf[1024];
			char *bufptr = buf;
			while (((*s >= '0') && (*s <= '9')) || ((*s >= 'a') && (*s <= 'z')) || ((*s >= 'A') && (*s <= 'A')) || (*s == '_') || (*s == '.'))
				*bufptr++ = *s++;
			*bufptr = 0;
			int res = args->get(buf);
			if (vars) *vars = true;
			return res;
		}
	}
	return 0;
}
Exemple #10
0
int Formula::eval_sum(char *&s, Args *args, bool *vars) const
{
	int left = eval_mul(s, args, vars);
	while (*s)
	{
		if (myisspace(*s))
		{
			++s;
		} else
		if (*s == '+')
		{
			left += eval_mul(++s, args, vars);
		} else
		if (*s == '-')
		{
			left -= eval_mul(++s, args, vars);
		} else
		{
			break;
		}
	}
	return left;
}
Exemple #11
0
/*
 * Find a non-boolean option, that is, "option=argument".  In accordance
 * with standard Linux practice, if this option is repeated, this returns
 * the last instance on the command line.
 *
 * Returns the length of the argument (regardless of if it was
 * truncated to fit in the buffer), or -1 on not found.
 */
int __cmdline_find_option(u32 cmdline_ptr, const char *option, char *buffer, int bufsize)
{
	addr_t cptr;
	char c;
	int len = -1;
	const char *opptr = NULL;
	char *bufptr = buffer;
	enum {
		st_wordstart,	/* Start of word/after whitespace */
		st_wordcmp,	/* Comparing this word */
		st_wordskip,	/* Miscompare, skip */
		st_bufcpy	/* Copying this to buffer */
	} state = st_wordstart;

	if (!cmdline_ptr || cmdline_ptr >= 0x100000)
		return -1;	/* No command line, or inaccessible */

	cptr = cmdline_ptr & 0xf;
	set_fs(cmdline_ptr >> 4);

	while (cptr < 0x10000 && (c = rdfs8(cptr++))) {
		switch (state) {
		case st_wordstart:
			if (myisspace(c))
				break;

			/* else */
			state = st_wordcmp;
			opptr = option;
			/* fall through */

		case st_wordcmp:
			if (c == '=' && !*opptr) {
				len = 0;
				bufptr = buffer;
				state = st_bufcpy;
			} else if (myisspace(c)) {
				state = st_wordstart;
			} else if (c != *opptr++) {
				state = st_wordskip;
			}
			break;

		case st_wordskip:
			if (myisspace(c))
				state = st_wordstart;
			break;

		case st_bufcpy:
			if (myisspace(c)) {
				state = st_wordstart;
			} else {
				if (len < bufsize-1)
					*bufptr++ = c;
				len++;
			}
			break;
		}
	}

	if (bufsize)
		*bufptr = '\0';

	return len;
}
Exemple #12
0
int picolParseEol(picolParser *p) {
    p->start = p->p;
    while(myisspace(*p->p) || *p->p == ';') { p->p++; p->len--; }
    RETURN_PARSED(PT_EOL);
}
Exemple #13
0
/**************************************************************
 * NAME
 *      loadent
 * ARGS
 *      infile - file to load from
 *      outfile - file to output noload records to
 * DESCR
 *      Load an entry into the structures.
 * RETRN
 *      Pointer to entry structure, NULL at eof or error.
 */
char *loadent( FILE *infile, FILE *outfile )
{
char *endent;       /* End of entry */
int recmark_in;     /* Note record marker already in */
int noload;         /* TRUE if noload marker detected in record 0.2q BJY */

if ( eofseen )                              /* If eof seen last time */
	return( NULL );                         /* Return eof */

endent = dicent;                            /* Init end of entry */
*endent++ = '\n';                           /* 0.2l BJY start record with nl */
*endent = '\0';                             /* Init entry content to null */
recmark_in = FALSE;                         /* Init record mark in */

noload = FALSE;                             /* begin 0.2q BJY */

while ( TRUE )
	{
#ifdef NO_NOLOAD /* 0.2s BJY */
	if ( recmark_in && ( !strncmp( noloadmark, line, noloadmarklen )    /* may be a nl after */
						 && myisspace( *(line+noloadmarklen) ) ) )      /* marker instead of space */
		{
		noload = TRUE;                      /* signal finding a noload record */
		}
#endif
	if ( !strncmp( recmark, line, recmarklen ) ) /* If line is record mark */
		{
		if ( !recmark_in )                  /* If no rec mark in yet */
			recmark_in = TRUE;              /* Remember this one */
#ifdef NO_NOLOAD /* 0.2s BJY */
		else if ( noload )                  /* begin 0.2q BJY */
			{
			fputs( dicent + 1, outfile );   /* output noload record now */
			endent = dicent;                /* reinitialize for new record */
			*endent++ = '\n';               /* 0.2l BJY start record with nl */
			*endent = '\0';
			noload = FALSE;                 /* end 0.2q BJY */
			}
#endif
		else                                /* Else return entry */
			break;
		}

#ifdef JUNK /* Leave Shoebox number line in */
	if ( strncmp( "\\_no", line, 4 ) )      /* If not shoebox number field */
#endif
		{
		strcpy( endent, line );             /* Copy line into entry */
		endent += strlen( line );           /* Update end of entry */
		}

		/*
		*   The following tests for overflow of entry, which should
		*   never happen.  But if it does, the code tries to make
		*   sure the dictionary is not mangled.
		*/
	if ( endent > endent_max )              /* If overflow of entry */
		break;                              /* Return first part */

	if ( !fgets ( line, MAXLINE, infile ) ) /* Get next line */
		{
		eofseen = TRUE;                     /* If none, remember eof */
		if ( recmark_in && noload )         /* begin 0.2q BJY */
			{                               /* don't process the last record */
			fputs( dicent + 1, outfile );   /* output noload record now */
			*(dicent+1) = '\0';             /* return blank record */
			}                               /* end 0.2q BJY */
		break;
		}
	}

return( dicent );
}
/**************************************************************
 * NAME
 *      applyrules
 * ARGS
 *      rules - list of rules to apply
 *      dicent - entry to apply rules to
 * DESC
 *      Apply rules to dic entry to add allomorphs.
 * RETN
 *      Pointer to modified entry.
 *
 * Major mods 5/95 0.2r BJY moved code into new func apply_rule()
 */
char *applyrules( Rule *rules, char *dicent )
{
Allo *al;           /* temporary allo pointer */
Rule *ru;           /* Temp rule */
char *s, *t;        /* Temp string pointer */
int i;              /* Index for cat array */
char *base;         /* Base form */
char remchar;       /* Removed char */
char *alloname;

if ( !rules )                       /* If no rules, return */
	return( dicent );

num_apps = 0;                       /* Clear number of rules applied */
allolist = NULL;                    /* Clear list of allos already in entry */
newallolist = NULL;                 /* 0.2r BJY */

s = strnlstr( dicent, basemark );           /* Find base */ /* 0.2l BJY */
if ( !s )                                   /* If no base, return */
	return( dicent );
s += basemarklen;                           /* Move to start of base */
											/* Find end of base */
for ( t = s;                                /* Stop at space or cutoff char */
		*t && !myisspace( *t ) && !( *t == cut_char );
		t++ );
remchar = *t;                               /* Remember char after base */
*t = '\0';                                  /* Terminate base */
base = mystrdup( s );                       /* Copy base */
*t = remchar;                               /* Restore char after base */

s = strnlstr( dicent, catmark );            /* Find category line */ /* 0.2l BJY */
if ( !s )                                   /* If no cat, use null */
	cat[0] = NULL;
else
	{
	for ( t = s;
			*t && !(*t == comment_char) && !(*t == '\n');
			t++ )                          /* Find comment or end of line */
		;
	remchar = *t;                           /* Remember char */
	*t = '\0';                              /* Cut off commment, if any */
	s = mystrdup( s );                      /* Copy cat line */
	*t = remchar;                           /* Restore char after cats */

	i = 0;                                  /* Init index */
	while ( *(s = nextwd( s ) ) )           /* While another cat */
		cat[i++] = s;                       /* Remember it */
	cat[i] = NULL;                          /* Terminate list with null */
	}

								/* Make a list of allos already in entry */
allolist = NULL;                            /* Clear list of allos */
s = dicent - 1;
while ( (s = strnlstr( s + 1, allomark )) != NULL ) /* While another allo */ /* 0.2l BJY */
	{
	s += allomarklen;               /* Move to start of allo */
	s = skipwhite(s);               /* wm: 0.2k: skip white space */
	for ( t = s; *t && !myisspace( *t ); t++ ) /* Find end of allo */
		;
	remchar = *t;                   /* Remember char after allo */
	*t = '\0';                      /* Terminate allo */
	add_allo( s );                  /* Add allo to list */
	*t = remchar;                   /* Restore char after allo */
	}

for ( ru = rules; ru; ru = ru->next )       /* For each rule */
	{                                       /* begin 0.2r BJY */
	if ( *ru->match || *ru->repl )          /* don't apply 0 -> 0 rule to new allos */
		{
		for ( al = newallolist; al; al = al->next )
			{                               /* now try on each PHONRULE generated allo */
/*            for ( s = al->name; s && !myisspace( *s ); s++)*/ /* find end of name */
/*                ;*/
			s = strchr( al->name, ' ' );

			if ( s )
				*s = '\0';
			alloname = mystrdup( al->name );
			if ( s )
				*s = ' ';                   /* restore space */
			apply_rule( alloname, ru, dicent, al );
			}
		}
	base = apply_rule( base, ru, dicent, NULL );   /* try rule on base word */ /* set base in case changed by base rule  0.2s BJY */
	}                                       /* end 0.2r BJY */

if ( base_becomes_allo                      /* If allo is base */
		&& !in_allolist( base ) )           /* And not already in */
	insert_line( allomark, base, after_allos( dicent ) ); /* Insert it into the entry */

num_ents++;                                 /* Count sentence */
if ( do_monitor )                           /* If monitor, give dot */
	{
	if (num_apps == 0)		/* hab 0.2p Conformed to standard practice */
	  putc('.', stderr);
	else if (num_apps < 10)
	  putc('0'+num_apps, stderr);
	else
	  putc('>', stderr);
	if ( num_ents % 100 == 0 )                      /* wm 0.2k: number by 100s */
		fprintf( stderr, " %5d", num_ents );
	if ( num_ents % 10 == 0 )
		fprintf( stderr, "  " );
	if ( num_ents % 50 == 0 )
		fprintf( stderr, "\n" );
	}

return( dicent );                             /* Return modified sent */
} /* function applyrules */
Exemple #15
0
int cmdline_find_option(const char *option, char *buffer, int bufsize)
{
	u32 cmdline_ptr = boot_params.hdr.cmd_line_ptr;
	addr_t cptr;
	char c;
	int len = -1;
	const char *opptr = NULL;
	char *bufptr = buffer;
	enum {
		st_wordstart,	
		st_wordcmp,	
		st_wordskip,	
		st_bufcpy	
	} state = st_wordstart;

	if (!cmdline_ptr || cmdline_ptr >= 0x100000)
		return -1;	

	cptr = cmdline_ptr & 0xf;
	set_fs(cmdline_ptr >> 4);

	while (cptr < 0x10000 && (c = rdfs8(cptr++))) {
		switch (state) {
		case st_wordstart:
			if (myisspace(c))
				break;

			
			state = st_wordcmp;
			opptr = option;
			

		case st_wordcmp:
			if (c == '=' && !*opptr) {
				len = 0;
				bufptr = buffer;
				state = st_bufcpy;
			} else if (myisspace(c)) {
				state = st_wordstart;
			} else if (c != *opptr++) {
				state = st_wordskip;
			}
			break;

		case st_wordskip:
			if (myisspace(c))
				state = st_wordstart;
			break;

		case st_bufcpy:
			if (myisspace(c)) {
				state = st_wordstart;
			} else {
				if (len < bufsize-1)
					*bufptr++ = c;
				len++;
			}
			break;
		}
	}

	if (bufsize)
		*bufptr = '\0';

	return len;
}
Exemple #16
0
/*
 * Find a non-boolean option, that is, "option=argument".  In accordance
 * with standard Linux practice, if this option is repeated, this returns
 * the last instance on the command line.
 *
 * Returns the length of the argument (regardless of if it was
 * truncated to fit in the buffer), or -1 on not found.
 */
int __cmdline_find_option(u32 cmdline_ptr, const char *option, char *buffer, int bufsize)
{
	addr_t cptr;
	char c;
	int len = -1;
	const char *opptr = NULL;
	char *bufptr = buffer;
	enum {
		st_wordstart,	/* Start of word/after whitespace */
		st_wordcmp,	/* Comparing this word */
		st_wordskip,	/* Miscompare, skip */
		st_bufcpy	/* Copying this to buffer */
	} state = st_wordstart;

	if (!cmdline_ptr || cmdline_ptr >= 0x100000) // cmdline 포인터가 없거나 1M이상이면 에러
		return -1;	/* No command line, or inaccessible */

	cptr = cmdline_ptr & 0xf; // cmdline_ptr의 오프셋
	set_fs(cmdline_ptr >> 4); // cmdline_ptr의 세그먼트 값
 // cmdline에서 옵션을 찾는다.
	while (cptr < 0x10000 && (c = rdfs8(cptr++))) {
		switch (state) {
		case st_wordstart:
			if (myisspace(c)) // 맨 처음 혹은 스페이스(<32)가 여러개 오면 break 해버린다.
				break;

			/* else */
			state = st_wordcmp; // 구분자 후에 문자가 있으면 wordcmp로 상태 변환
			opptr = option; // 찾을 옵션
			/* fall through */
			// 아래로 계속된다.
		case st_wordcmp:
			if (c == '=' && !*opptr) {
				len = 0; // 길이 리셋
				bufptr = buffer;
				state = st_bufcpy; // 일치한다. bufcpy로 상태전환
			} else if (myisspace(c)) {
				state = st_wordstart; // "="이 없다. 다시 비교
			} else if (c != *opptr++) {
				state = st_wordskip; // 일치하지 않음
			}
			break; // 문자가 일치한다. cmp 상태 그대로 다시 비교

		case st_wordskip: // skip은 문자열이 일치하지 않은 상태
			if (myisspace(c)) // 구분자가 오면 새로 비교 시작
				state = st_wordstart;
			break;

		case st_bufcpy:
			if (myisspace(c)) {
				state = st_wordstart; // 구분자가 오기전까지 복사
			} else {
				if (len < bufsize-1)
					*bufptr++ = c; // 버퍼 크기를 넘지 않으면 복사
				len++;
			}
			break;
		}
	}

	if (bufsize)
		*bufptr = '\0'; // 버퍼 끝은 NUL

	return len; // 옵션 길이를 리턴. 일치하는게 없으면 -1
}