luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
iverilog/vpi/sys_scanf.c

606 lines
13 KiB
C
Raw Blame History

/*
* Copyright (c) 2006 Stephen Williams (steve@icarus.com)
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CVS_IDENT
#ident "$Id: sys_scanf.c,v 1.8 2007/04/16 00:09:58 steve Exp $"
#endif
/* round() is ISO C99 from math.h. This define should enable it. */
# define _ISOC99_SOURCE 1
# define _SVID_SOURCE 1
# include "vpi_user.h"
# include "sys_priv.h"
# include <ctype.h>
# include <string.h>
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <assert.h>
struct byte_source {
const char*str;
FILE*fd;
};
static int byte_getc(struct byte_source*byte)
{
int ch;
if (byte->str) {
if (byte->str[0] == 0)
return EOF;
return *(byte->str)++;
}
ch = fgetc(byte->fd);
// fprintf(stderr, "byte_getc --> '%c' (%d)\n", ch, ch);
return ch;
}
static void byte_ungetc(struct byte_source*src, int ch)
{
if (ch == EOF)
return;
if (src->str) {
src->str -= 1;
return;
}
assert(src->fd);
ungetc(ch, src->fd);
}
static PLI_INT32 sys_fscanf_compiletf(PLI_BYTE8*name)
{
return 0;
}
/*
* This function matches the input characters of a floating point
* number and generates a floating point (double) from that string.
*/
static double float_string(struct byte_source*src)
{
int ch;
char*str = 0;
size_t len;
double sign_flag = 1.0;
ch = byte_getc(src);
if (ch == '+') {
sign_flag = 1.0;
ch = byte_getc(src);
} else if (ch == '-') {
sign_flag = -1.0;
ch = byte_getc(src);
}
str = malloc(1);
len = 0;
*str = 0;
while (isdigit(ch)) {
str = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
}
if (ch == '.') {
str = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
while (isdigit(ch)) {
str = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
}
}
if (ch == 'e' || ch == 'E') {
str = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
if (ch == '-' || ch == '+') {
str = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
}
while (isdigit(ch)) {
src = realloc(str, len+2);
str[len++] = ch;
ch = byte_getc(src);
}
}
str[len] = 0;
sign_flag *= strtod(str, 0);
free(str);
if (ch != EOF)
byte_ungetc(src, ch);
return sign_flag;
}
static int scan_format_float(struct byte_source*src,
vpiHandle arg)
{
s_vpi_value val;
val.format = vpiRealVal;
val.value.real = float_string(src);
vpi_put_value(arg, &val, 0, vpiNoDelay);
return 1;
}
static int scan_format_float_time(vpiHandle sys,
struct byte_source*src,
vpiHandle arg)
{
vpiHandle scope = vpi_handle(vpiScope, sys);
int time_units = vpi_get(vpiTimeUnit, scope);
double scale;
s_vpi_value val;
val.format = vpiRealVal;
val.value.real = float_string(src);
/* Round the value to the specified precision. Handle this bit
by shifting the decimal point to the precision where we
want to round, do the rounding, then shift the point back */
scale = pow(10.0, timeformat_info.prec);
val.value.real = round(val.value.real*scale) / scale;
/* Change the units from the timeformat to the timescale. */
scale = pow(10.0, timeformat_info.units - time_units);
val.value.real *= scale;
vpi_put_value(arg, &val, 0, vpiNoDelay);
return 1;
}
/*
* Match the %s format by loading a string of non-space characters.
*/
static int scan_format_string(struct byte_source*src, vpiHandle arg)
{
char*tmp = malloc(1);
size_t len = 0;
s_vpi_value val;
int ch;
*tmp = 0;
ch = byte_getc(src);
while (!isspace(ch)) {
if (ch == EOF)
break;
tmp = realloc(tmp, len+1);
tmp[len++] = ch;
ch = byte_getc(src);
}
if (ch == EOF && len == 0)
return 0;
if (ch != EOF)
byte_ungetc(src, ch);
tmp[len] = 0;
val.format = vpiStringVal;
val.value.str = tmp;
vpi_put_value(arg, &val, 0, vpiNoDelay);
free(tmp);
return 1;
}
/*
* The $fscanf and $sscanf functions are the same except for the first
* argument, which is the source. The wrapper functions below peel off
* the first argument and make a byte_source object that then gets
* passed to this function, which processes the rest of the function.
*/
static int scan_format(vpiHandle sys, struct byte_source*src, vpiHandle argv)
{
s_vpi_value val;
vpiHandle item;
char*fmt, *fmtp;
int rc = 0;
int ch;
int match_fail = 0;
/* Get the format string. */
item = vpi_scan(argv);
assert(item);
val.format = vpiStringVal;
vpi_get_value(item, &val);
fmtp = fmt = strdup(val.value.str);
while ( fmtp && *fmtp != 0 && !match_fail) {
if (isspace(*fmtp)) {
/* White space matches a string of white space in
the input. The number of spaces is not
relevent, and the match may be 0 or more
spaces. */
while (*fmtp && isspace(*fmtp))
fmtp += 1;
ch = byte_getc(src);
while (isspace(ch))
ch = byte_getc(src);
if (ch != EOF)
byte_ungetc(src, ch);
} else if (*fmtp != '%') {
/* Characters other than % match themselves. */
ch = byte_getc(src);
if (ch != *fmtp) {
byte_ungetc(src, ch);
break;
}
fmtp += 1;
} else {
/* We are at a pattern character. The pattern has
the format %<N>x no matter what the x code, so
parse it generically first. */
int suppress_flag = 0;
int length_field = -1;
int code = 0;
int sign_flag = 1;
PLI_INT32 value;
char*tmp;
fmtp += 1;
if (*fmtp == '*') {
suppress_flag = 1;
fmtp += 1;
}
if (isdigit(*fmtp)) {
length_field = 0;
while (isdigit(*fmtp)) {
length_field *= 10;
length_field += *fmtp - '0';
fmtp += 1;
}
}
code = *fmtp;
fmtp += 1;
/* The format string is parsed:
- length_field is the length,
- code is the format code character,
- suppress_flag is true if the length is an arg.
Now we interpret the code. */
switch (code) {
/* Read a '%' character from the input. */
case '%':
ch = byte_getc(src);
if (ch != '%') {
byte_ungetc(src, ch);
fmtp = 0;
}
break;
/* Read a binary integer. If there is a match,
store that integer in the next argument and
increment the completion count. */
case 'b':
/* binary integer */
tmp = malloc(2);
value = 0;
tmp[0] = 0;
match_fail = 1;
ch = byte_getc(src);
while (strchr("01xXzZ?_", ch)) {
match_fail = 0;
if (ch == '?')
ch = 'x';
if (ch != '_') {
ch = tolower(ch);
tmp[value++] = ch;
tmp = realloc(tmp, value+1);
tmp[value] = 0;
}
ch = byte_getc(src);
}
byte_ungetc(src, ch);
if (match_fail) {
free(tmp);
break;
}
/* Matched a binary value, put it to an argument. */
item = vpi_scan(argv);
assert(item);
val.format = vpiBinStrVal;
val.value.str = tmp;
vpi_put_value(item, &val, 0, vpiNoDelay);
free(tmp);
rc += 1;
break;
case 'c':
ch = byte_getc(src);
item = vpi_scan(argv);
assert(item);
val.format = vpiIntVal;
val.value.integer = ch;
vpi_put_value(item, &val, 0, vpiNoDelay);
rc += 1;
break;
case 'd':
match_fail = 1;
/* Decimal integer */
ch = byte_getc(src);
if (ch == '-') {
sign_flag = -1;
ch = byte_getc(src);
}
value = 0;
while ( isdigit(ch) ) {
match_fail = 0;
value *= 10;
value += ch - '0';
ch = byte_getc(src);
}
if (match_fail)
break;
item = vpi_scan(argv);
assert(item);
val.format = vpiIntVal;
val.value.integer = value * sign_flag;
vpi_put_value(item, &val, 0, vpiNoDelay);
rc += 1;
break;
case 'e':
case 'f':
case 'g':
item = vpi_scan(argv);
assert(item);
rc += scan_format_float(src, item);
break;
case 'h':
case 'x':
match_fail = 1;
/* Hex integer */
tmp = malloc(2);
value = 0;
tmp[0] = 0;
ch = byte_getc(src);
while (strchr("0123456789abcdefABCDEFxXzZ?_", ch)) {
match_fail = 0;
if (ch == '?')
ch = 'x';
if (ch != '_') {
ch = tolower(ch);
tmp[value++] = ch;
tmp = realloc(tmp, value+1);
tmp[value] = 0;
}
ch = byte_getc(src);
}
byte_ungetc(src, ch);
if (match_fail) {
free(tmp);
break;
}
item = vpi_scan(argv);
assert(item);
val.format = vpiHexStrVal;
val.value.str = tmp;
vpi_put_value(item, &val, 0, vpiNoDelay);
free(tmp);
rc += 1;
break;
case 'o':
match_fail = 1;
/* binary integer */
tmp = malloc(2);
value = 0;
tmp[0] = 0;
ch = byte_getc(src);
while (strchr("01234567xXzZ?_", ch)) {
match_fail = 0;
if (ch == '?')
ch = 'x';
if (ch != '_') {
ch = tolower(ch);
tmp[value++] = ch;
tmp = realloc(tmp, value+1);
tmp[value] = 0;
}
ch = byte_getc(src);
}
byte_ungetc(src, ch);
if (match_fail) {
free(tmp);
break;
}
item = vpi_scan(argv);
assert(item);
val.format = vpiOctStrVal;
val.value.str = tmp;
vpi_put_value(item, &val, 0, vpiNoDelay);
free(tmp);
rc += 1;
break;
case 's':
item = vpi_scan(argv);
assert(item);
rc += scan_format_string(src, item);
break;
case 't':
item = vpi_scan(argv);
assert(item);
rc += scan_format_float_time(sys, src, item);
break;
default:
vpi_printf("$scanf: Unknown format code: %c\n", code);
break;
}
}
}
free(fmt);
vpi_free_object(argv);
val.format = vpiIntVal;
val.value.integer = rc;
vpi_put_value(sys, &val, 0, vpiNoDelay);
return 0;
}
static PLI_INT32 sys_fscanf_calltf(PLI_BYTE8*name)
{
s_vpi_value val;
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, sys);
vpiHandle item;
struct byte_source src;
FILE*fd;
item = vpi_scan(argv);
assert(item);
val.format = vpiIntVal;
vpi_get_value(item, &val);
fd = vpi_get_file(val.value.integer);
assert(fd);
src.str = 0;
src.fd = fd;
scan_format(sys, &src, argv);
return 0;
}
static PLI_INT32 sys_sscanf_compiletf(PLI_BYTE8*name)
{
return 0;
}
static PLI_INT32 sys_sscanf_calltf(PLI_BYTE8*name)
{
s_vpi_value val;
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, sys);
vpiHandle item;
struct byte_source src;
char*str;
item = vpi_scan(argv);
assert(item);
val.format = vpiStringVal;
vpi_get_value(item, &val);
str = strdup(val.value.str);
src.str = str;
src.fd = 0;
scan_format(sys, &src, argv);
free(str);
return 0;
}
/*
* All the Xscanf functions return a 32bit value.
*/
static PLI_INT32 sys_fscanf_sizetf(PLI_BYTE8*x)
{
return 32;
}
void sys_scanf_register()
{
s_vpi_systf_data tf_data;
//============================== fscanf
tf_data.type = vpiSysFunc;
tf_data.tfname = "$fscanf";
tf_data.calltf = sys_fscanf_calltf;
tf_data.compiletf = sys_fscanf_compiletf;
tf_data.sizetf = sys_fscanf_sizetf;
tf_data.user_data = "$fscanf";
vpi_register_systf(&tf_data);
//============================== sscanf
tf_data.type = vpiSysFunc;
tf_data.tfname = "$sscanf";
tf_data.calltf = sys_sscanf_calltf;
tf_data.compiletf = sys_sscanf_compiletf;
tf_data.sizetf = sys_fscanf_sizetf;
tf_data.user_data = "$sscanf";
vpi_register_systf(&tf_data);
}
Reference in New Issue View Git Blame Copy Permalink