minix/usr.bin/fsplit/fsplit.c
Thomas Cort 97b7aef1ba Importing usr.bin/fsplit
No Minix-specific changes needed.

Change-Id: I78021e6485b40a5b9f98b5d0e5ce0dc82b1ae46a
2013-10-27 16:55:12 -04:00

501 lines
11 KiB
C

/*
* Copyright (c) 1983, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Asa Romberger and Jerry Berkman.
*
* 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.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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 <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1983, 1993\
The Regents of the University of California. All rights reserved.");
#endif /* not lint */
#ifndef lint
#if 0
static char sccsid[] = "from: @(#)fsplit.c 8.1 (Berkeley) 6/6/93";
#else
__RCSID("$NetBSD: fsplit.c,v 1.28 2011/09/16 15:39:26 joerg Exp $");
#endif
#endif /* not lint */
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
#include <ctype.h>
#include <err.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/*
* usage: fsplit [-e efile] ... [file]
*
* split single file containing source for several fortran programs
* and/or subprograms into files each containing one
* subprogram unit.
* each separate file will be named using the corresponding subroutine,
* function, block data or program name if one is found; otherwise
* the name will be of the form mainNNN.f or blkdtaNNN.f .
* If a file of that name exists, it is saved in a name of the
* form zzz000.f .
* If -e option is used, then only those subprograms named in the -e
* option are split off; e.g.:
* fsplit -esub1 -e sub2 prog.f
* isolates sub1 and sub2 in sub1.f and sub2.f. The space
* after -e is optional.
*
* Modified Feb., 1983 by Jerry Berkman, Computing Services, U.C. Berkeley.
* - added comments
* - more function types: double complex, character*(*), etc.
* - fixed minor bugs
* - instead of all unnamed going into zNNN.f, put mains in
* mainNNN.f, block datas in blkdtaNNN.f, dups in zzzNNN.f .
*/
#define BSZ 512
static char buf[BSZ];
static FILE *ifp;
static char x[] = "zzz000.f";
static char mainp[] = "main000.f";
static char blkp[] = "blkdta000.f";
__dead static void badparms(void);
static const char *functs(const char *);
static int get_line(void);
static void get_name(char *, int);
static int lend(void);
static int lname(char *, size_t);
static const char *look(const char *, const char *);
static int saveit(const char *);
static int scan_name(char *, size_t, const char *);
static const char *skiplab(const char *);
static const char *skipws(const char *);
struct extract {
bool found;
char *name;
};
#define MAXEXTONLY 100
static struct extract extonly[MAXEXTONLY];
static int numextonly = 0;
int
main(int argc, char **argv)
{
FILE *ofp; /* output file */
int rv; /* 1 if got card in output file, 0 otherwise */
int nflag; /* 1 if got name of subprog., 0 otherwise */
int retval, i, ch;
char name[80];
while ((ch = getopt(argc, argv, "e:")) != -1) {
switch (ch) {
case 'e':
if (numextonly >= MAXEXTONLY) {
errx(1, "Too many -e options");
}
extonly[numextonly].name = optarg;
extonly[numextonly].found = false;
numextonly++;
break;
default:
badparms();
break;
}
}
if (argc > 2) {
badparms();
} else if (argc == 2) {
if ((ifp = fopen(argv[1], "r")) == NULL) {
err(1, "%s", argv[1]);
}
} else {
ifp = stdin;
}
for (;;) {
/*
* Look for a temp file that doesn't correspond to an
* existing file.
*/
get_name(x, 3);
ofp = fopen(x, "w");
if (ofp == NULL) {
err(1, "%s", x);
}
nflag = 0;
rv = 0;
while (get_line() > 0) {
rv = 1;
fprintf(ofp, "%s", buf);
/* look for an 'end' statement */
if (lend()) {
break;
}
/* if no name yet, try and find one */
if (nflag == 0) {
nflag = lname(name, sizeof(name));
}
}
fclose(ofp);
if (rv == 0) {
/* no lines in file, forget the file */
unlink(x);
retval = 0;
for (i = 0; i < numextonly; i++) {
if (!extonly[i].found) {
retval = 1;
warnx("%s not found", extonly[i].name);
}
}
exit(retval);
}
if (nflag) {
/* rename the file */
if (saveit(name)) {
struct stat sbuf;
if (stat(name, &sbuf) < 0) {
if (rename(x, name) < 0) {
warn("%s: rename", x);
printf("%s left in %s\n",
name, x);
} else {
printf("%s\n", name);
}
continue;
} else if (strcmp(name, x) == 0) {
printf("%s\n", x);
continue;
}
printf("%s already exists, put in %s\n",
name, x);
continue;
} else {
unlink(x);
continue;
}
}
if (numextonly == 0) {
printf("%s\n", x);
} else {
unlink(x);
}
}
}
static void
badparms(void)
{
err(1, "Usage: fsplit [-e efile] ... [file]");
}
static int
saveit(const char *name)
{
int i;
char fname[50];
size_t fnamelen;
if (numextonly == 0) {
return 1;
}
strlcpy(fname, name, sizeof(fname));
fnamelen = strlen(fname);
assert(fnamelen > 2);
assert(fname[fnamelen-2] = '.');
assert(fname[fnamelen-1] = 'f');
fname[fnamelen-2] = '\0';
for (i = 0; i < numextonly; i++) {
if (strcmp(fname, extonly[i].name) == 0) {
extonly[i].found = true;
return 1;
}
}
return 0;
}
static void
get_name(char *name, int letters)
{
struct stat sbuf;
char *ptr;
while (stat(name, &sbuf) >= 0) {
for (ptr = name + letters + 2; ptr >= name + letters; ptr--) {
(*ptr)++;
if (*ptr <= '9')
break;
*ptr = '0';
}
if (ptr < name + letters) {
errx(1, "Ran out of file names.\n");
}
}
}
static int
get_line(void)
{
char *ptr;
for (ptr = buf; ptr < &buf[BSZ]; ) {
*ptr = getc(ifp);
if (feof(ifp))
return -1;
if (*ptr++ == '\n') {
*ptr = '\0';
return 1;
}
}
while (getc(ifp) != '\n' && feof(ifp) == 0) {
/* nothing */
}
warnx("Line truncated to %d characters.", BSZ);
return 1;
}
/*
* Return 1 for 'end' alone on card (up to col. 72), 0 otherwise.
*/
static int
lend(void)
{
const char *p;
if ((p = skiplab(buf)) == 0) {
return 0;
}
p = skipws(p);
if (*p != 'e' && *p != 'E') {
return 0;
}
p++;
p = skipws(p);
if (*p != 'n' && *p != 'N') {
return 0;
}
p++;
p = skipws(p);
if (*p != 'd' && *p != 'D') {
return 0;
}
p++;
p = skipws(p);
if (p - buf >= 72 || *p == '\n') {
return 1;
}
return 0;
}
/*
* check for keywords for subprograms
* return 0 if comment card, 1 if found
* name and put in arg string. invent name for unnamed
* block datas and main programs.
*/
static int
lname(char *s, size_t l)
{
#define LINESIZE 80
const char *ptr, *p;
char line[LINESIZE], *iptr = line;
/* first check for comment cards */
if (buf[0] == 'c' || buf[0] == 'C' || buf[0] == '*') {
return 0;
}
ptr = skipws(buf);
if (*ptr == '\n') {
return 0;
}
ptr = skiplab(buf);
if (ptr == NULL) {
return 0;
}
/* copy to buffer and converting to lower case */
p = ptr;
while (*p && p <= &buf[71] ) {
*iptr = tolower((unsigned char)*p);
iptr++;
p++;
}
*iptr = '\n';
if ((ptr = look(line, "subroutine")) != NULL ||
(ptr = look(line, "function")) != NULL ||
(ptr = functs(line)) != NULL) {
if (scan_name(s, l, ptr)) {
return 1;
}
strlcpy(s, x, l);
} else if ((ptr = look(line, "program")) != NULL) {
if (scan_name(s, l, ptr)) {
return 1;
}
get_name(mainp, 4);
strlcpy(s, mainp, l);
} else if ((ptr = look(line, "blockdata")) != NULL) {
if (scan_name(s, l, ptr)) {
return 1;
}
get_name(blkp, 6);
strlcpy(s, blkp, l);
} else if ((ptr = functs(line)) != NULL) {
if (scan_name(s, l, ptr)) {
return 1;
}
strlcpy(s, x, l);
} else {
get_name(mainp, 4);
strlcpy(s, mainp, l);
}
return 1;
}
static int
scan_name(char *s, size_t smax, const char *ptr)
{
char *sptr;
size_t sptrmax;
/* scan off the name */
ptr = skipws(ptr);
sptr = s;
sptrmax = smax - 3;
while (*ptr != '(' && *ptr != '\n') {
if (*ptr != ' ' && *ptr != '\t' && *ptr != '/') {
if (sptrmax == 0) {
/* Not sure this is the right thing, so warn */
warnx("Output name too long; truncated");
break;
}
*sptr++ = *ptr;
sptrmax--;
}
ptr++;
}
if (sptr == s) {
return 0;
}
*sptr++ = '.';
*sptr++ = 'f';
*sptr++ = '\0';
return 1;
}
/*
* look for typed functions such as: real*8 function,
* character*16 function, character*(*) function
*/
static const char *
functs(const char *p)
{
const char *ptr;
if ((ptr = look(p, "character")) != NULL ||
(ptr = look(p, "logical")) != NULL ||
(ptr = look(p, "real")) != NULL ||
(ptr = look(p, "integer")) != NULL ||
(ptr = look(p, "doubleprecision")) != NULL ||
(ptr = look(p, "complex")) != NULL ||
(ptr = look(p, "doublecomplex")) != NULL) {
while (*ptr == ' ' || *ptr == '\t' || *ptr == '*'
|| (*ptr >= '0' && *ptr <= '9')
|| *ptr == '(' || *ptr == ')') {
ptr++;
}
ptr = look(ptr, "function");
return ptr;
}
else {
return NULL;
}
}
/*
* if first 6 col. blank, return ptr to col. 7,
* if blanks and then tab, return ptr after tab,
* else return NULL (labelled statement, comment or continuation)
*/
static const char *
skiplab(const char *p)
{
const char *ptr;
for (ptr = p; ptr < &p[6]; ptr++) {
if (*ptr == ' ')
continue;
if (*ptr == '\t') {
ptr++;
break;
}
return NULL;
}
return ptr;
}
/*
* return NULL if m doesn't match initial part of s;
* otherwise return ptr to next char after m in s
*/
static const char *
look(const char *s, const char *m)
{
const char *sp, *mp;
sp = s; mp = m;
while (*mp) {
sp = skipws(sp);
if (*sp++ != *mp++)
return NULL;
}
return sp;
}
static const char *
skipws(const char *p)
{
while (*p == ' ' || *p == '\t') {
p++;
}
return p;
}