NetBSD/dist/pdisk/io.c

464 lines
7.8 KiB
C
Raw Normal View History

//
// io.c - simple io and input parsing routines
//
// Written by Eryk Vershen
//
/*
* Copyright 1996,1997,1998 by Apple Computer, Inc.
* All Rights Reserved
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both the copyright notice and this permission notice appear in
* supporting documentation.
*
* APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
* NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
// for *printf()
#include <stdio.h>
// for malloc() & free()
#if !defined(__linux__)
#include <stdlib.h>
#else
#include <malloc.h>
#endif
// for strncpy()
#include <string.h>
// for va_start(), etc.
#include <stdarg.h>
// for errno
#include <errno.h>
#include "io.h"
#include "errors.h"
//
// Defines
//
#define BAD_DIGIT 17 /* must be greater than any base */
#define STRING_CHUNK 16
#define UNGET_MAX_COUNT 10
#ifndef __linux__
#ifndef __unix__
#define SCSI_FD 8
#endif
#ifdef NeXT
#define loff_t off_t
#define llseek lseek
#else
#define loff_t long
#define llseek lseek
#endif
#endif
//
// Types
//
//
// Global Constants
//
const long kDefault = -1;
//
// Global Variables
//
short unget_buf[UNGET_MAX_COUNT+1];
int unget_count;
char io_buffer[MAXIOSIZE];
//
// Forward declarations
//
long get_number(int first_char);
char* get_string(int eos);
int my_getch(void);
void my_ungetch(int c);
//
// Routines
//
int
my_getch()
{
if (unget_count > 0) {
return (unget_buf[--unget_count]);
} else {
return (getc(stdin));
}
}
void
my_ungetch(int c)
{
// In practice there is never more than one character in
// the unget_buf, but what's a little overkill among friends?
if (unget_count < UNGET_MAX_COUNT) {
unget_buf[unget_count++] = c;
} else {
fatal(-1, "Programmer error in my_ungetch().");
}
}
void
flush_to_newline(int keep_newline)
{
int c;
for (;;) {
c = my_getch();
if (c <= 0) {
break;
} else if (c == '\n') {
if (keep_newline) {
my_ungetch(c);
}
break;
} else {
// skip
}
}
return;
}
int
get_okay(const char *prompt, int default_value)
{
int c;
flush_to_newline(0);
printf(prompt);
for (;;) {
c = my_getch();
if (c <= 0) {
break;
} else if (c == ' ' || c == '\t') {
// skip blanks and tabs
} else if (c == '\n') {
my_ungetch(c);
return default_value;
} else if (c == 'y' || c == 'Y') {
return 1;
} else if (c == 'n' || c == 'N') {
return 0;
} else {
flush_to_newline(0);
printf(prompt);
}
}
return -1;
}
int
get_command(const char *prompt, int promptBeforeGet, int *command)
{
int c;
if (promptBeforeGet) {
printf(prompt);
}
for (;;) {
c = my_getch();
if (c <= 0) {
break;
} else if (c == ' ' || c == '\t') {
// skip blanks and tabs
} else if (c == '\n') {
printf(prompt);
} else {
*command = c;
return 1;
}
}
return 0;
}
int
get_number_argument(const char *prompt, long *number, long default_value)
{
int c;
int result = 0;
for (;;) {
c = my_getch();
if (c <= 0) {
break;
} else if (c == ' ' || c == '\t') {
// skip blanks and tabs
} else if (c == '\n') {
if (default_value == kDefault) {
printf(prompt);
} else {
my_ungetch(c);
*number = default_value;
result = 1;
break;
}
} else if ('0' <= c && c <= '9') {
*number = get_number(c);
result = 1;
break;
} else {
my_ungetch(c);
*number = 0;
break;
}
}
return result;
}
long
get_number(int first_char)
{
register int c;
int base;
int digit;
int ret_value;
if (first_char != '0') {
c = first_char;
base = 10;
digit = BAD_DIGIT;
} else if ((c=my_getch()) == 'x' || c == 'X') {
c = my_getch();
base = 16;
digit = BAD_DIGIT;
} else {
my_ungetch(c);
c = first_char;
base = 8;
digit = 0;
}
ret_value = 0;
for (ret_value = 0; ; c = my_getch()) {
if (c >= '0' && c <= '9') {
digit = c - '0';
} else if (c >='A' && c <= 'F') {
digit = 10 + (c - 'A');
} else if (c >='a' && c <= 'f') {
digit = 10 + (c - 'a');
} else {
digit = BAD_DIGIT;
}
if (digit >= base) {
break;
}
ret_value = ret_value * base + digit;
}
my_ungetch(c);
return(ret_value);
}
int
get_string_argument(const char *prompt, char **string, int reprompt)
{
int c;
int result = 0;
for (;;) {
c = my_getch();
if (c <= 0) {
break;
} else if (c == ' ' || c == '\t') {
// skip blanks and tabs
} else if (c == '\n') {
if (reprompt) {
printf(prompt);
} else {
my_ungetch(c);
*string = NULL;
break;
}
} else if (c == '"' || c == '\'') {
*string = get_string(c);
result = 1;
break;
} else if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
|| (c == '-' || c == '/' || c == '.' || c == ':')) {
my_ungetch(c);
*string = get_string(' ');
result = 1;
break;
} else {
my_ungetch(c);
*string = NULL;
break;
}
}
return result;
}
char *
get_string(int eos)
{
int c;
char *s;
char *ret_value;
char *limit;
int length;
ret_value = (char *) malloc(STRING_CHUNK);
if (ret_value == NULL) {
error(errno, "can't allocate memory for string buffer");
return NULL;
}
length = STRING_CHUNK;
limit = ret_value + length;
c = my_getch();
for (s = ret_value; ; c = my_getch()) {
if (s >= limit) {
// expand string
limit = (char *) malloc(length+STRING_CHUNK);
if (limit == NULL) {
error(errno, "can't allocate memory for string buffer");
ret_value[length-1] = 0;
break;
}
strncpy(limit, ret_value, length);
free(ret_value);
s = limit + (s - ret_value);
ret_value = limit;
length += STRING_CHUNK;
limit = ret_value + length;
}
if (c <= 0 || c == eos || (eos == ' ' && c == '\t')) {
*s++ = 0;
break;
} else if (c == '\n') {
*s++ = 0;
my_ungetch(c);
break;
} else {
*s++ = c;
}
}
return(ret_value);
}
unsigned long
get_multiplier(long divisor)
{
int c;
unsigned long result;
unsigned long extra;
c = my_getch();
extra = 1;
if (c <= 0 || divisor <= 0) {
result = 0;
} else if (c == 't' || c == 'T') {
result = 1024*1024;
extra = 1024*1024;
} else if (c == 'g' || c == 'G') {
result = 1024*1024*1024;
} else if (c == 'm' || c == 'M') {
result = 1024*1024;
} else if (c == 'k' || c == 'K') {
result = 1024;
} else {
my_ungetch(c);
result = 1;
}
if (result > 1) {
if (extra > 1) {
result /= divisor;
if (result >= 4096) {
/* overflow -> 20bits + >12bits */
result = 0;
} else {
result *= extra;
}
} else if (result >= divisor) {
result /= divisor;
} else {
result = 1;
}
}
return result;
}
int
get_partition_modifier(void)
{
int c;
int result;
result = 0;
c = my_getch();
if (c == 'p' || c == 'P') {
result = 1;
} else if (c > 0) {
my_ungetch(c);
}
return result;
}
int
number_of_digits(unsigned long value)
{
int j;
j = 1;
while (value > 9) {
j++;
value = value / 10;
}
return j;
}
//
// Print a message on standard error & flush the input.
//
void
bad_input(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
flush_to_newline(1);
}