에프에이리눅스 / 1611_0007_prime_oven

Blame view

kernel/linux-imx6_3.14.28/arch/x86/boot/string.c 2.69 KB
edit raw normal view history
6b13f685e   김민수   BSP 최초 추가 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
  /* -*- linux-c -*- ------------------------------------------------------- *
   *
   *   Copyright (C) 1991, 1992 Linus Torvalds
   *   Copyright 2007 rPath, Inc. - All Rights Reserved
   *
   *   This file is part of the Linux kernel, and is made available under
   *   the terms of the GNU General Public License version 2.
   *
   * ----------------------------------------------------------------------- */
  
  /*
   * Very basic string functions
   */
  
  #include "boot.h"
  
  int strcmp(const char *str1, const char *str2)
  {
  	const unsigned char *s1 = (const unsigned char *)str1;
  	const unsigned char *s2 = (const unsigned char *)str2;
  	int delta = 0;
  
  	while (*s1 || *s2) {
  		delta = *s2 - *s1;
  		if (delta)
  			return delta;
  		s1++;
  		s2++;
  	}
  	return 0;
  }
  
  int strncmp(const char *cs, const char *ct, size_t count)
  {
  	unsigned char c1, c2;
  
  	while (count) {
  		c1 = *cs++;
  		c2 = *ct++;
  		if (c1 != c2)
  			return c1 < c2 ? -1 : 1;
  		if (!c1)
  			break;
  		count--;
  	}
  	return 0;
  }
  
  size_t strnlen(const char *s, size_t maxlen)
  {
  	const char *es = s;
  	while (*es && maxlen) {
  		es++;
  		maxlen--;
  	}
  
  	return (es - s);
  }
  
  unsigned int atou(const char *s)
  {
  	unsigned int i = 0;
  	while (isdigit(*s))
  		i = i * 10 + (*s++ - '0');
  	return i;
  }
  
  /* Works only for digits and letters, but small and fast */
  #define TOLOWER(x) ((x) | 0x20)
  
  static unsigned int simple_guess_base(const char *cp)
  {
  	if (cp[0] == '0') {
  		if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
  			return 16;
  		else
  			return 8;
  	} else {
  		return 10;
  	}
  }
  
  /**
   * simple_strtoull - convert a string to an unsigned long long
   * @cp: The start of the string
   * @endp: A pointer to the end of the parsed string will be placed here
   * @base: The number base to use
   */
  
  unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
  {
  	unsigned long long result = 0;
  
  	if (!base)
  		base = simple_guess_base(cp);
  
  	if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
  		cp += 2;
  
  	while (isxdigit(*cp)) {
  		unsigned int value;
  
  		value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
  		if (value >= base)
  			break;
  		result = result * base + value;
  		cp++;
  	}
  	if (endp)
  		*endp = (char *)cp;
  
  	return result;
  }
  
  /**
   * strlen - Find the length of a string
   * @s: The string to be sized
   */
  size_t strlen(const char *s)
  {
  	const char *sc;
  
  	for (sc = s; *sc != '\0'; ++sc)
  		/* nothing */;
  	return sc - s;
  }
  
  /**
   * strstr - Find the first substring in a %NUL terminated string
   * @s1: The string to be searched
   * @s2: The string to search for
   */
  char *strstr(const char *s1, const char *s2)
  {
  	size_t l1, l2;
  
  	l2 = strlen(s2);
  	if (!l2)
  		return (char *)s1;
  	l1 = strlen(s1);
  	while (l1 >= l2) {
  		l1--;
  		if (!memcmp(s1, s2, l2))
  			return (char *)s1;
  		s1++;
  	}
  	return NULL;
  }