[apple/xnu.git] / libsa / vers_rsrc.c

#include <libsa/vers_rsrc.h>
#include <sys/systm.h>


int isdigit(char c) {
    return (c == '0' ||
        c == '1' || c == '2' || c == '3' ||
        c == '4' || c == '5' || c == '6' ||
        c == '7' || c == '8' || c == '9');
}

int isspace(char c) {
    return (c == ' ' ||
        c == '\t' ||
        c == '\r' ||
        c == '\n');
}


int isreleasestate(char c) {
    return (c == 'd' || c == 'a' || c == 'b' || c == 'f');
}


UInt8 BCD_digit_for_char(char c) {
    switch (c) {
      case '0': return 0; break;
      case '1': return 1; break;
      case '2': return 2; break;
      case '3': return 3; break;
      case '4': return 4; break;
      case '5': return 5; break;
      case '6': return 6; break;
      case '7': return 7; break;
      case '8': return 8; break;
      case '9': return 9; break;
      default:  return BCD_illegal; break;
    }
    return BCD_illegal;
}


char BCD_char_for_digit(UInt8 digit) {
    switch (digit) {
      case 0:  return '0'; break;
      case 1:  return '1'; break;
      case 2:  return '2'; break;
      case 3:  return '3'; break;
      case 4:  return '4'; break;
      case 5:  return '5'; break;
      case 6:  return '6'; break;
      case 7:  return '7'; break;
      case 8:  return '8'; break;
      case 9:  return '9'; break;
      default: return '?'; break;
    }
    return '?';
}


VERS_revision VERS_revision_for_string(char ** string_p) {
    char * string;

    if (!string_p || !*string_p) {
        return VERS_invalid;
    }

    string = *string_p;

    if (isspace(string[0]) || string[0] == '\0') {
        return VERS_release;
    } else {
        switch (string[0]) {
          case 'd':
              if (isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_development;
              }
              break;
          case 'a':
              if (isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_alpha;
              }
              break;
          case 'b':
              if (isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_beta;
              }
              break;
          case 'f':
              if (isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_candidate;
              } else if (string[1] == 'c' && isdigit(string[2])) {
                  *string_p = &string[2];
                  return VERS_candidate;
              } else {
                  return VERS_invalid;
              }
              break;
          default:
              return VERS_invalid;
              break;
        }
    }

    return VERS_invalid;
}


int VERS_parse_string(const char * vers_string, UInt32 * version_num) {
    int result = 1;
    VERS_version vers;
    char * current_char_p;
    UInt8  scratch;

    if (!vers_string || *vers_string == '\0') {
        return 0;
    }

    vers.vnum = 0;

    current_char_p = &vers_string[0];


   /*****
    * Check for an initial digit of the major release number.
    */
    vers.bytes[0] = BCD_digit_for_char(*current_char_p);
    if (vers.bytes[0] == BCD_illegal) {
        return 0;
    }

    current_char_p++;


   /*****
    * Check for a second digit of the major release number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (isdigit(*current_char_p)) {
        scratch = BCD_digit_for_char(*current_char_p);
        if (scratch == BCD_illegal) {
            return 0;
        }
        vers.bytes[0] = BCD_combine(vers.bytes[0], scratch);
        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else if (*current_char_p == '.') {
            current_char_p++;
        } else {
            return 0;
        }
    } else if (isreleasestate(*current_char_p)) {
        goto release_state;
    } else if (*current_char_p == '.') {
        current_char_p++;
    } else {
        return 0;
    }


   /*****
    * Check for the minor release number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (isdigit(*current_char_p)) {
        vers.bytes[1] = BCD_digit_for_char(*current_char_p);
        if (vers.bytes[1] == BCD_illegal) {
            return 0;
        }

        // Make sure its the first nibble of byte 1!
        vers.bytes[1] = BCD_combine(vers.bytes[1], 0);

        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else if (*current_char_p == '.') {
            current_char_p++;
        } else {
            return 0;
        }
    } else {
        return 0;
    }


   /*****
    * Check for the bugfix number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (isdigit(*current_char_p)) {
        scratch = BCD_digit_for_char(*current_char_p);
        if (scratch == BCD_illegal) {
            return 0;
        }

        /* vers.bytes[1] has its left nibble set already */
        vers.bytes[1] = vers.bytes[1] | scratch;

        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else {
            return 0;
        }
    } else {
        return 0;
    }


release_state:

   /*****
    * Check for the release state.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else {
        vers.bytes[2] = VERS_revision_for_string(&current_char_p);
        if (vers.bytes[2] == VERS_invalid) {
            return 0;
        }
    }


   /*****
    * Get the nonrelease revision number (0..255).
    */
    if (vers.bytes[2] != VERS_release) {
        UInt32 revision_num = 0;
        int    i;

        if (*current_char_p == '\0' || !isdigit(*current_char_p)) {
            return 0;
        }
        for (i = 0; i < 3 && *current_char_p != '\0'; i++, current_char_p++) {
            UInt8 scratch_digit;
            scratch_digit = BCD_digit_for_char(*current_char_p);
            if (scratch_digit == BCD_illegal) {
                return 0;
            }
            revision_num *= 10;
            revision_num += scratch_digit;
        }
        if (isdigit(*current_char_p) || revision_num > 255) {
            return 0;
        }
        vers.bytes[3] = (UInt8)revision_num;
    }

    if (vers.bytes[2] == VERS_release) {
        vers.bytes[3] = 0xff;
    } else {
        if (vers.bytes[2] == VERS_candidate) {
            if (vers.bytes[3] == 0) {
                return 0;
            } else {
                vers.bytes[2] = VERS_release;
                vers.bytes[3]--;
            }
        }
    }

finish:
    *version_num = vers.vnum;
    return result;
}


#define VERS_STRING_MAX_LEN  (12)

int VERS_string(char * buffer, UInt32 length, UInt32 vers) {
    VERS_version version;
    int cpos = 0;
    int result = 1;

    char major1;
    char major2;
    char minor;
    char bugfix;

    version.vnum = vers;

   /* No buffer, length less than longest possible vers string,
    * return 0.
    */
    if (!buffer || length < VERS_STRING_MAX_LEN) {
        result = -1;
        goto finish;
    }

    bzero(buffer, length * sizeof(char));


   /*****
    * Major version number.
    */
    major1 = BCD_char_for_digit(BCD_get_left(version.bytes[0]));
    if (major1 == '?') {
        result = 0;
    } /* this is not an 'else' situation */
    if (major1 != '0') {
        buffer[cpos] = major1;
        cpos++;
    }

    major2 = BCD_char_for_digit(BCD_get_right(version.bytes[0]));
    if (major2 == '?') {
        result = 0;
    }

    buffer[cpos] = major2;
    cpos++;


   /*****
    * Minor & bug-fix version numbers.
    */
    minor = BCD_char_for_digit(BCD_get_left(version.bytes[1]));
    if (minor == '?') {
        result = 0;
    }
    bugfix = BCD_char_for_digit(BCD_get_right(version.bytes[1]));
    if (bugfix == '?') {
        result = 0;
    }


   /* Always display the minor version number.
    */
    buffer[cpos] = '.';
    cpos++;
    buffer[cpos] = minor;
    cpos++;


   /* Only display the bugfix version number if it's nonzero.
    */
    if (bugfix != '0') {
        buffer[cpos] = '.';
        cpos++;
        buffer[cpos] = bugfix;
        cpos++;
    }


   /* If the release state is final, we're done!
    */
    if (version.bytes[2] == VERS_release && version.bytes[3] == 255) {
        result = 0;
        goto finish;
    }


   /*****
    * Do the release state and update level.
    */
    switch (version.bytes[2]) {
      case VERS_development:
        buffer[cpos] = 'd';
        cpos++;
        break;
      case VERS_alpha:
        buffer[cpos] = 'a';
        cpos++;
        break;
      case VERS_beta:
        buffer[cpos] = 'b';
        cpos++;
        break;
      case VERS_release: 
        if (version.bytes[3] < 255) {
            buffer[cpos] = 'f';
            buffer[cpos+1] = 'c';
            cpos += 2;
        } else {
            result = 1;
            goto finish;
        }
        break;
      default:
        result = 0;
        buffer[cpos] = '?';
        cpos++;
        break;
    }

    if (version.bytes[2] != VERS_release) {
        sprintf(&buffer[cpos], "%d", version.bytes[3]);
    } else {
        if (version.bytes[3] < 255) {
            sprintf(&buffer[cpos], "%d", version.bytes[3] + 1);
        }
    }

finish:
    return result;
}
Commit	Line	Data
1c79356b A	1	#include <libsa/vers_rsrc.h>
	2	#include <sys/systm.h>
	3
	4
	5	int isdigit(char c) {
	6	return (c == '0' \|\|
	7	c == '1' \|\| c == '2' \|\| c == '3' \|\|
	8	c == '4' \|\| c == '5' \|\| c == '6' \|\|
	9	c == '7' \|\| c == '8' \|\| c == '9');
	10	}
	11
	12	int isspace(char c) {
	13	return (c == ' ' \|\|
	14	c == '\t' \|\|
	15	c == '\r' \|\|
	16	c == '\n');
	17	}
	18
	19
	20	int isreleasestate(char c) {
	21	return (c == 'd' \|\| c == 'a' \|\| c == 'b' \|\| c == 'f');
	22	}
	23
	24
	25	UInt8 BCD_digit_for_char(char c) {
	26	switch (c) {
	27	case '0': return 0; break;
	28	case '1': return 1; break;
	29	case '2': return 2; break;
	30	case '3': return 3; break;
	31	case '4': return 4; break;
	32	case '5': return 5; break;
	33	case '6': return 6; break;
	34	case '7': return 7; break;
	35	case '8': return 8; break;
	36	case '9': return 9; break;
	37	default: return BCD_illegal; break;
	38	}
	39	return BCD_illegal;
	40	}
	41
	42
	43	char BCD_char_for_digit(UInt8 digit) {
	44	switch (digit) {
	45	case 0: return '0'; break;
	46	case 1: return '1'; break;
	47	case 2: return '2'; break;
	48	case 3: return '3'; break;
	49	case 4: return '4'; break;
	50	case 5: return '5'; break;
	51	case 6: return '6'; break;
	52	case 7: return '7'; break;
	53	case 8: return '8'; break;
	54	case 9: return '9'; break;
	55	default: return '?'; break;
	56	}
	57	return '?';
	58	}
	59
	60
	61	VERS_revision VERS_revision_for_string(char ** string_p) {
	62	char * string;
	63
	64	if (!string_p \|\| !*string_p) {
65	return VERS_invalid;
66	}
67
68	string = *string_p;
69
70	if (isspace(string[0]) \|\| string[0] == '\0') {
71	return VERS_release;
72	} else {
73	switch (string[0]) {
74	case 'd':
75	if (isdigit(string[1])) {
76	*string_p = &string[1];
77	return VERS_development;
78	}
79	break;
80	case 'a':
81	if (isdigit(string[1])) {
82	*string_p = &string[1];
83	return VERS_alpha;
84	}
85	break;
86	case 'b':
87	if (isdigit(string[1])) {
88	*string_p = &string[1];
89	return VERS_beta;
90	}
91	break;
92	case 'f':
93	if (isdigit(string[1])) {
94	*string_p = &string[1];
95	return VERS_candidate;
96	} else if (string[1] == 'c' && isdigit(string[2])) {
97	*string_p = &string[2];
98	return VERS_candidate;
99	} else {
100	return VERS_invalid;
101	}
102	break;
103	default:
104	return VERS_invalid;
105	break;
106	}
107	}
108
109	return VERS_invalid;
110	}
111
112
0b4e3aa0	113	int VERS_parse_string(const char * vers_string, UInt32 * version_num) {
1c79356b A	114	int result = 1;
	115	VERS_version vers;
	116	char * current_char_p;
	117	UInt8 scratch;
	118
	119	if (!vers_string \|\| *vers_string == '\0') {
	120	return 0;
	121	}
	122
	123	vers.vnum = 0;
	124
	125	current_char_p = &vers_string[0];
	126
	127
	128	/*****
	129	* Check for an initial digit of the major release number.
	130	*/
	131	vers.bytes[0] = BCD_digit_for_char(*current_char_p);
	132	if (vers.bytes[0] == BCD_illegal) {
	133	return 0;
	134	}
	135
	136	current_char_p++;
	137
	138
	139	/*****
	140	* Check for a second digit of the major release number.
	141	*/
	142	if (*current_char_p == '\0') {
	143	vers.bytes[2] = VERS_release;
	144	vers.bytes[3] = 0xff;
	145	goto finish;
	146	} else if (isdigit(*current_char_p)) {
	147	scratch = BCD_digit_for_char(*current_char_p);
	148	if (scratch == BCD_illegal) {
	149	return 0;
	150	}
	151	vers.bytes[0] = BCD_combine(vers.bytes[0], scratch);
	152	current_char_p++;
	153
	154	if (*current_char_p == '\0') {
	155	vers.bytes[2] = VERS_release;
	156	vers.bytes[3] = 0xff;
	157	goto finish;
	158	} else if (isreleasestate(*current_char_p)) {
	159	goto release_state;
	160	} else if (*current_char_p == '.') {
	161	current_char_p++;
	162	} else {
	163	return 0;
	164	}
	165	} else if (isreleasestate(*current_char_p)) {
	166	goto release_state;
	167	} else if (*current_char_p == '.') {
	168	current_char_p++;
	169	} else {
	170	return 0;
	171	}
	172
	173
	174	/*****
	175	* Check for the minor release number.
	176	*/
	177	if (*current_char_p == '\0') {
178	vers.bytes[2] = VERS_release;
179	vers.bytes[3] = 0xff;
180	goto finish;
181	} else if (isdigit(*current_char_p)) {
182	vers.bytes[1] = BCD_digit_for_char(*current_char_p);
183	if (vers.bytes[1] == BCD_illegal) {
184	return 0;
185	}
186
187	// Make sure its the first nibble of byte 1!
188	vers.bytes[1] = BCD_combine(vers.bytes[1], 0);
189
190	current_char_p++;
191
192	if (*current_char_p == '\0') {
193	vers.bytes[2] = VERS_release;
194	vers.bytes[3] = 0xff;
195	goto finish;
196	} else if (isreleasestate(*current_char_p)) {
197	goto release_state;
198	} else if (*current_char_p == '.') {
199	current_char_p++;
200	} else {
201	return 0;
202	}
203	} else {
204	return 0;
205	}
206
207
208	/*****
209	* Check for the bugfix number.
210	*/
211	if (*current_char_p == '\0') {
212	vers.bytes[2] = VERS_release;
213	vers.bytes[3] = 0xff;
214	goto finish;
215	} else if (isdigit(*current_char_p)) {
216	scratch = BCD_digit_for_char(*current_char_p);
217	if (scratch == BCD_illegal) {
218	return 0;
219	}
220
221	/* vers.bytes[1] has its left nibble set already */
222	vers.bytes[1] = vers.bytes[1] \| scratch;
223
224	current_char_p++;
225
226	if (*current_char_p == '\0') {
227	vers.bytes[2] = VERS_release;
228	vers.bytes[3] = 0xff;
229	goto finish;
230	} else if (isreleasestate(*current_char_p)) {
231	goto release_state;
232	} else {
233	return 0;
234	}
235	} else {
236	return 0;
237	}
238
239
240	release_state:
241
242	/*****
243	* Check for the release state.
244	*/
245	if (*current_char_p == '\0') {
246	vers.bytes[2] = VERS_release;
247	vers.bytes[3] = 0xff;
248	goto finish;
249	} else {
250	vers.bytes[2] = VERS_revision_for_string(&current_char_p);
251	if (vers.bytes[2] == VERS_invalid) {
252	return 0;
253	}
254	}
255
256
257	/*****
258	* Get the nonrelease revision number (0..255).
259	*/
260	if (vers.bytes[2] != VERS_release) {
261	UInt32 revision_num = 0;
262	int i;
263
264	if (current_char_p == '\0' \|\| !isdigit(current_char_p)) {
265	return 0;
266	}
267	for (i = 0; i < 3 && *current_char_p != '\0'; i++, current_char_p++) {
268	UInt8 scratch_digit;
269	scratch_digit = BCD_digit_for_char(*current_char_p);
270	if (scratch_digit == BCD_illegal) {
271	return 0;
272	}
273	revision_num *= 10;
274	revision_num += scratch_digit;
275	}
276	if (isdigit(*current_char_p) \|\| revision_num > 255) {
277	return 0;
278	}
279	vers.bytes[3] = (UInt8)revision_num;
280	}
281
282	if (vers.bytes[2] == VERS_release) {
283	vers.bytes[3] = 0xff;
284	} else {
285	if (vers.bytes[2] == VERS_candidate) {
286	if (vers.bytes[3] == 0) {
287	return 0;
288	} else {
289	vers.bytes[2] = VERS_release;
290	vers.bytes[3]--;
291	}
292	}
293	}
294
295	finish:
296	*version_num = vers.vnum;
297	return result;
298	}
299
300
301	#define VERS_STRING_MAX_LEN (12)
302
303	int VERS_string(char * buffer, UInt32 length, UInt32 vers) {
304	VERS_version version;
305	int cpos = 0;
306	int result = 1;
307
308	char major1;
309	char major2;
310	char minor;
311	char bugfix;
312
313	version.vnum = vers;
314
315	/* No buffer, length less than longest possible vers string,
316	* return 0.
317	*/
318	if (!buffer \|\| length < VERS_STRING_MAX_LEN) {
319	result = -1;
320	goto finish;
321	}
322
323	bzero(buffer, length * sizeof(char));
324
325
326	/*****
327	* Major version number.
328	*/
329	major1 = BCD_char_for_digit(BCD_get_left(version.bytes[0]));
330	if (major1 == '?') {
331	result = 0;
332	} /* this is not an 'else' situation */
333	if (major1 != '0') {
334	buffer[cpos] = major1;
335	cpos++;
336	}
337
338	major2 = BCD_char_for_digit(BCD_get_right(version.bytes[0]));
339	if (major2 == '?') {
340	result = 0;
341	}
342
343	buffer[cpos] = major2;
344	cpos++;
345
346
347	/*****
348	* Minor & bug-fix version numbers.
349	*/
350	minor = BCD_char_for_digit(BCD_get_left(version.bytes[1]));
351	if (minor == '?') {
352	result = 0;
353	}
354	bugfix = BCD_char_for_digit(BCD_get_right(version.bytes[1]));
355	if (bugfix == '?') {
356	result = 0;
357	}
358
359
360	/* Always display the minor version number.
361	*/
362	buffer[cpos] = '.';
363	cpos++;
364	buffer[cpos] = minor;
365	cpos++;
366
367
368	/* Only display the bugfix version number if it's nonzero.
369	*/
370	if (bugfix != '0') {
371	buffer[cpos] = '.';
372	cpos++;
373	buffer[cpos] = bugfix;
374	cpos++;
375	}
376
377
378	/* If the release state is final, we're done!
379	*/
380	if (version.bytes[2] == VERS_release && version.bytes[3] == 255) {
381	result = 0;
382	goto finish;
383	}
384
385
386	/*****
387	* Do the release state and update level.
388	*/
389	switch (version.bytes[2]) {
390	case VERS_development:
391	buffer[cpos] = 'd';
392	cpos++;
393	break;
394	case VERS_alpha:
395	buffer[cpos] = 'a';
396	cpos++;
397	break;
398	case VERS_beta:
399	buffer[cpos] = 'b';
400	cpos++;
401	break;
402	case VERS_release:
403	if (version.bytes[3] < 255) {
404	buffer[cpos] = 'f';
405	buffer[cpos+1] = 'c';
406	cpos += 2;
407	} else {
408	result = 1;
409	goto finish;
410	}
411	break;
412	default:
413	result = 0;
414	buffer[cpos] = '?';
415	cpos++;
416	break;
417	}
418
419	if (version.bytes[2] != VERS_release) {
420	sprintf(&buffer[cpos], "%d", version.bytes[3]);
421	} else {
422	if (version.bytes[3] < 255) {
423	sprintf(&buffer[cpos], "%d", version.bytes[3] + 1);
424	}
425	}
426
427	finish:
428	return result;
429	}