779 lines
14 KiB
C
779 lines
14 KiB
C
/* $NetBSD: methods.c,v 1.7 2011/01/14 13:31:47 minoura Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 1999 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Minoura Makoto.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <err.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "memswitch.h"
|
|
#include "methods.h"
|
|
|
|
int
|
|
atoi_(p)
|
|
const char **p;
|
|
{
|
|
const char *p1 = *p;
|
|
int v = 0;
|
|
int first = 1;
|
|
|
|
while (*p1 == ' ' || *p1 == '\t')
|
|
p1++;
|
|
|
|
if (*p1 == 0) {
|
|
*p = 0;
|
|
return 0;
|
|
}
|
|
if (strlen(p1) >= 2 && strncasecmp("0x", p1, 2) == 0) {
|
|
p1 += 2;
|
|
while (1) {
|
|
if (*p1 >= '0' && *p1 <= '9') {
|
|
v *= 16;
|
|
v += *p1 - '0';
|
|
first = 0;
|
|
} else if (*p1 >= 'A' && *p1 <= 'F') {
|
|
v *= 16;
|
|
v += *p1 - 'A' + 10;
|
|
first = 0;
|
|
} else if (*p1 >= 'a' && *p1 <= 'f') {
|
|
v *= 16;
|
|
v += *p1 - 'a' + 10;
|
|
first = 0;
|
|
} else {
|
|
break;
|
|
}
|
|
p1++;
|
|
}
|
|
} else {
|
|
while (1) {
|
|
if (*p1 >= '0' && *p1 <= '9') {
|
|
v *= 10;
|
|
v += *p1 - '0';
|
|
first = 0;
|
|
} else {
|
|
break;
|
|
}
|
|
p1++;
|
|
}
|
|
}
|
|
|
|
if (first) {
|
|
*p = 0;
|
|
return 0;
|
|
}
|
|
|
|
while (*p1 == ' ' || *p1 == '\t') p1++;
|
|
*p = p1;
|
|
return v;
|
|
}
|
|
|
|
int
|
|
fill_uchar(prop)
|
|
struct property *prop;
|
|
{
|
|
if (current_values == 0)
|
|
alloc_current_values();
|
|
|
|
prop->current_value.byte[0] = current_values[prop->offset];
|
|
prop->current_value.byte[1] = 0;
|
|
prop->current_value.byte[2] = 0;
|
|
prop->current_value.byte[3] = 0;
|
|
prop->value_valid = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fill_ushort(prop)
|
|
struct property *prop;
|
|
{
|
|
if (current_values == 0)
|
|
alloc_current_values();
|
|
|
|
prop->current_value.byte[0] = current_values[prop->offset];
|
|
prop->current_value.byte[1] = current_values[prop->offset+1];
|
|
prop->current_value.byte[2] = 0;
|
|
prop->current_value.byte[3] = 0;
|
|
prop->value_valid = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fill_ulong(prop)
|
|
struct property *prop;
|
|
{
|
|
if (current_values == 0)
|
|
alloc_current_values();
|
|
|
|
prop->current_value.byte[0] = current_values[prop->offset];
|
|
prop->current_value.byte[1] = current_values[prop->offset+1];
|
|
prop->current_value.byte[2] = current_values[prop->offset+2];
|
|
prop->current_value.byte[3] = current_values[prop->offset+3];
|
|
prop->value_valid = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
flush_uchar(prop)
|
|
struct property *prop;
|
|
{
|
|
if (!prop->modified)
|
|
return 0;
|
|
|
|
if (modified_values == 0)
|
|
alloc_modified_values();
|
|
|
|
modified_values[prop->offset] = prop->modified_value.byte[0];
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
flush_ushort(prop)
|
|
struct property *prop;
|
|
{
|
|
if (!prop->modified)
|
|
return 0;
|
|
|
|
if (modified_values == 0)
|
|
alloc_modified_values();
|
|
|
|
modified_values[prop->offset] = prop->modified_value.byte[0];
|
|
modified_values[prop->offset+1] = prop->modified_value.byte[1];
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
flush_ulong(prop)
|
|
struct property *prop;
|
|
{
|
|
if (!prop->modified)
|
|
return 0;
|
|
|
|
if (modified_values == 0)
|
|
alloc_modified_values();
|
|
|
|
modified_values[prop->offset] = prop->modified_value.byte[0];
|
|
modified_values[prop->offset+1] = prop->modified_value.byte[1];
|
|
modified_values[prop->offset+2] = prop->modified_value.byte[2];
|
|
modified_values[prop->offset+3] = prop->modified_value.byte[3];
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
flush_dummy(prop)
|
|
struct property *prop;
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_dummy(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
warnx("Cannot modify %s.%s", prop->class, prop->node);
|
|
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
parse_byte(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
|
|
v = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (strcasecmp("MB", p) == 0)
|
|
v *= 1024 * 1024;
|
|
else if (strcasecmp("KB", p) == 0)
|
|
v *= 1024;
|
|
else if (*p != 0 &&
|
|
strcasecmp("B", p) != 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (v < prop->min) {
|
|
warnx("%s: Too small", value);
|
|
return -1;
|
|
} else if (v > prop->max) {
|
|
warnx("%s: Too large", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.longword = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_uchar(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
|
|
v = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (v < prop->min) {
|
|
warnx("%s: Too small", value);
|
|
return -1;
|
|
} else if (v > prop->max) {
|
|
warnx("%s: Too large", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.byte[0] = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_ulong(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
|
|
v = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (v < prop->min) {
|
|
warnx("%s: Too small", value);
|
|
return -1;
|
|
} else if (v > prop->max) {
|
|
warnx("%s: Too large", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.longword = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_ushort(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
|
|
v = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (v < prop->min) {
|
|
warnx("%s: Too small", value);
|
|
return -1;
|
|
} else if (v > prop->max) {
|
|
warnx("%s: Too large", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.word[0] = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_time(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (*p == '-') {
|
|
p++;
|
|
v = -atoi_(&p);
|
|
} else
|
|
v = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (strcasecmp("hours", p) == 0 || strcasecmp("hour", p) == 0)
|
|
v *= 60 * 60;
|
|
else if (strcasecmp("minutes", p) == 0 ||
|
|
strcasecmp("minute", p) == 0)
|
|
v *= 60;
|
|
else if (*p != 0 &&
|
|
strcasecmp("second", p) != 0 &&
|
|
strcasecmp("seconds", p) != 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
if (v < prop->min) {
|
|
warnx("%s: Too small", value);
|
|
return -1;
|
|
} else if (v > prop->max) {
|
|
warnx("%s: Too large", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.longword = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_bootdev(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
const char *p = value;
|
|
int v;
|
|
char expr_scsi[32];
|
|
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
|
|
if (strcasecmp("STD", p) == 0)
|
|
v = 0;
|
|
else if (strcasecmp("ROM", p) == 0)
|
|
v = 0xa000;
|
|
else if (strcasecmp("RAM", p) == 0)
|
|
v = 0xb000;
|
|
else if (strncasecmp("HD", p, 2) == 0) {
|
|
p += 2;
|
|
v = atoi_(&p);
|
|
if (p == 0 || v < 0 || v > 15) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
v *= 0x0100;
|
|
v += 0x8000;
|
|
} else if (strncasecmp("FD", p, 2) == 0) {
|
|
p += 2;
|
|
v = atoi_(&p);
|
|
if (p == 0 || v < 0 || v > 3) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
v *= 0x0100;
|
|
v += 0x9070;
|
|
} else if (strncasecmp("INSCSI", p, 6) == 0 ||
|
|
strncasecmp("EXSCSI", p, 6) == 0) {
|
|
int isin = strncasecmp("EXSCSI", p, 6);
|
|
|
|
p += 6;
|
|
v = atoi_(&p);
|
|
if (p == 0 || v < 0 || v > 7) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
/* change boot.romaddr */
|
|
sprintf(expr_scsi, "boot.romaddr=0x%06x",
|
|
(isin ? 0xfc0000 : 0xea0020) + v * 4);
|
|
modify_single(expr_scsi);
|
|
|
|
/* boot.device again */
|
|
v = 0xa000;
|
|
} else {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.word[0] = v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
parse_serial(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
#define NEXTSPEC while (*p == ' ' || *p == '\t') p++; \
|
|
if (*p++ != ',') { \
|
|
warnx("%s: Invalid value", value); \
|
|
return -1; \
|
|
} \
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
{
|
|
const char *p = value;
|
|
const char *q;
|
|
int baud, bit, parity, stop, flow;
|
|
static const int bauds[] = {75, 150, 300, 600, 1200, 2400, 4800, 9600,
|
|
17361, 0};
|
|
static const char parities[] = "noe";
|
|
int i;
|
|
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
|
|
/* speed */
|
|
baud = atoi_(&p);
|
|
if (p == 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
for (i = 0; bauds[i]; i++)
|
|
if (baud == bauds[i])
|
|
break;
|
|
if (bauds[i] == 0) {
|
|
warnx("%d: Invalid speed", baud);
|
|
return -1;
|
|
}
|
|
baud = i;
|
|
|
|
NEXTSPEC;
|
|
|
|
/* bit size */
|
|
if (*p < '5' || *p > '8') {
|
|
warnx("%c: Invalid bit size", *p);
|
|
return -1;
|
|
}
|
|
bit = *p++ - '5';
|
|
|
|
NEXTSPEC;
|
|
|
|
/* parity */
|
|
q = strchr(parities, *p++);
|
|
if (q == 0) {
|
|
warnx("%c: Invalid parity spec", *p);
|
|
return -1;
|
|
}
|
|
parity = q - parities;
|
|
|
|
NEXTSPEC;
|
|
|
|
/* stop bit */
|
|
if (strncmp(p, "1.5", 3) == 0) {
|
|
stop = 2;
|
|
p += 3;
|
|
} else if (strncmp(p, "2", 1) == 0) {
|
|
stop = 0;
|
|
p++;
|
|
} else if (strncmp(p, "1", 1) == 0) {
|
|
stop = 1;
|
|
p++;
|
|
} else {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
NEXTSPEC;
|
|
|
|
/* flow */
|
|
if (*p == '-')
|
|
flow = 0;
|
|
else if (*p == 's')
|
|
flow = 1;
|
|
else {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
p++;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (*p != 0) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.word[0] = ((stop << 14) +
|
|
(parity << 12) +
|
|
(bit << 10) +
|
|
(flow << 9) +
|
|
baud);
|
|
|
|
return 0;
|
|
}
|
|
#undef NEXTSPEC
|
|
|
|
int
|
|
parse_srammode(prop, value)
|
|
struct property *prop;
|
|
const char *value;
|
|
{
|
|
static const char *const sramstrs[] = {"unused", "SRAMDISK", "program"};
|
|
int i;
|
|
|
|
for (i = 0; i <= 2; i++) {
|
|
if (strcasecmp(value, sramstrs[i]) == 0)
|
|
break;
|
|
}
|
|
if (i > 2) {
|
|
warnx("%s: Invalid value", value);
|
|
return -1;
|
|
}
|
|
|
|
prop->modified = 1;
|
|
prop->modified_value.byte[0] = i;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_uchar(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"%d", prop->modified_value.byte[0]);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN, "%d",
|
|
prop->current_value.byte[0]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_ucharh(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%4.4x", prop->modified_value.byte[0]);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%4.4x", prop->current_value.byte[0]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_ushorth(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%4.4x", prop->modified_value.word[0]);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%4.4x", prop->current_value.word[0]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_ulong(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"%ld", prop->modified_value.longword);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN,
|
|
"%ld", prop->current_value.longword);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_ulongh(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%8.8lx", prop->modified_value.longword);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN,
|
|
"0x%8.8lx", prop->current_value.longword);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_magic(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN, "%c%c%c%c",
|
|
prop->current_value.byte[0],
|
|
prop->current_value.byte[1],
|
|
prop->current_value.byte[2],
|
|
prop->current_value.byte[3]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_timesec(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
if (prop->modified)
|
|
snprintf(str, MAXVALUELEN,
|
|
"%ld second", prop->modified_value.longword);
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
snprintf(str, MAXVALUELEN,
|
|
"%ld second", prop->current_value.longword);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_bootdev(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
unsigned int v;
|
|
|
|
if (prop->modified)
|
|
v = prop->modified_value.word[0];
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
v = prop->current_value.word[0];
|
|
}
|
|
|
|
if (v == 0)
|
|
strcpy(str, "STD");
|
|
else if (v == 0xa000)
|
|
strcpy(str, "ROM");
|
|
else if (v == 0xb000)
|
|
strcpy(str, "RAM");
|
|
else if (v >= 0x8000 && v < 0x9000)
|
|
snprintf(str, MAXVALUELEN, "HD%d", (v & 0x0f00) >> 8);
|
|
else if (v >= 0x9000 && v < 0xa000)
|
|
snprintf(str, MAXVALUELEN, "FD%d", (v & 0x0f00) >> 8);
|
|
else
|
|
snprintf(str, MAXVALUELEN, "%8.8x", v);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_serial(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
unsigned int v;
|
|
const char *baud, *stop;
|
|
char bit, parity, flow;
|
|
static const char *const bauds[] = {"75", "150", "300", "600", "1200",
|
|
"2400", "4800", "9600", "17361"};
|
|
static const char bits[] = "5678";
|
|
static const char parities[] = "noen";
|
|
static const char *const stops[] = {"2", "1", "1.5", "2"};
|
|
static const char flows[] = "-s";
|
|
|
|
if (prop->modified)
|
|
v = prop->modified_value.word[0];
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
v = prop->current_value.word[0];
|
|
}
|
|
|
|
baud = bauds[v & 0x000f];
|
|
bit = bits[(v & 0x0c00) >> 10];
|
|
parity = parities[(v & 0x3000) >> 12];
|
|
stop = stops[(v & 0xe000) >> 14];
|
|
flow = flows[(v & 0x0200) >> 9];
|
|
sprintf(str, "%s,%c,%c,%s,%c", baud, bit, parity, stop, flow);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
print_srammode(prop, str)
|
|
struct property *prop;
|
|
char *str;
|
|
{
|
|
int v;
|
|
static const char *const sramstrs[] = {"unused", "SRAMDISK", "program"};
|
|
|
|
if (prop->modified)
|
|
v = prop->modified_value.byte[0];
|
|
else {
|
|
if (!prop->value_valid)
|
|
prop->fill(prop);
|
|
v = prop->current_value.byte[0];
|
|
}
|
|
|
|
if (v < 0 || v > 2)
|
|
strcpy(str, "INVALID");
|
|
else
|
|
strcpy(str, sramstrs[v]);
|
|
|
|
return 0;
|
|
}
|