/*
 * This source file is part of Vahunz,
 * a tool to make source code un-/more legible.
 *
 *--------------------------------------------------------------------------
 *
 * Vahunz and the Ugly library are Copyright (C) 1998 by
 * Thomas Aglassinger <agi@giga.or.at>
 *
 * All rights reserved.
 *
 * Refer to the manual for more information.
 *
 *--------------------------------------------------------------------------
 *
 * Ubiqx library is Copyright (C) 1991-1998 by
 * Christopher R. Hertel <crh@ubiqx.mn.org>
 *
 * Ubiqx library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <time.h>
#ifdef AMIGA
#include <dos/dos.h>
#include <proto/dos.h>
#define j1Z 1
#endif
#include "ubiqx/ubi_AVLtree.h"
#include "ugly/utypes.h"
#define STRPTR char * 
#include "ugly/umemory.h"
#include "ugly/ustring.h"
#include "ugly/expstr.h"
#include "vahunz_rev.h"
#include "vahunz/keywords.c"
#define g2U 0
#define u0Y 1
struct s8G
{
h7L Node; 
STRPTR r5N; 
STRPTR u6C; 
ULONG j7Pq; 
char w8C; 
};
typedef struct s8G x9J;
void m0Q(void)
{
#if g2U
fprintf(stderr, "*vahunz* [%d] ", errno);
#endif
}
void d3Z(void)
{
#if g2U
fprintf(stderr, "\n");
#endif
}
void g8M(const char *format,...)
{
#if g2U
va_list j5P;
va_start(j5P, format);
m0Q();
vfprintf(stderr, format, j5P);
d3Z();
va_end(j5P);
#else
#endif
}
void a0Gr(int a0C)
{
#if g2U
char z1Z[20];
STRPTR y0K = z1Z;
switch (a0C)
{
case '\n':
y0K = "\\n";
break;
case '\r':
y0K = "\\r";
break;
case '\t':
y0K = "\\t";
break;
default:
if (a0C == EOF)
{
y0K = "\\EOF\\";
}
else if ((a0C >= 32) || (a0C <= 127))
{
sprintf(z1Z, "%c", a0C);
}
else
{
sprintf(z1Z, "\\0x%02x\\", a0C);
}
}
fprintf(stderr, "%s", y0K);
fflush(stderr);
#endif
}
y8M u8Qh; 
static int f7X(k8U x1B, u8Ol l9P)
{
STRPTR q6S = (STRPTR) x1B;
x9J *k0W = (x9J *) l9P;
return (strcmp(q6S, k0W->r5N));
}
static int q2Y(k8U x1B, u8Ol l9P)
{
STRPTR q6S = (STRPTR) x1B;
x9J *k0W = (x9J *) l9P;
return (strcmp(q6S, k0W->u6C));
}
static void l7B(u8Ol l9P, void *n5T)
{
x9J *b1X = (x9J *) l9P;
char *s6I = (char *) n5T;
g8M("%s: %c `%s' --> `%s'", s6I,
b1X->w8C, b1X->r5N, b1X->u6C);
}
static void g2W(u8Ol l9P)
{
x9J *b1X = (x9J *) l9P;
g8M("kill: `%s'", b1X->r5N);
l5D(b1X->r5N);
l5D(l9P);
}
static x9J *i8W(const STRPTR z9J)
{
u8Ol r3V = e6K(&u8Qh, z9J);
return ((x9J *) r3V);
}
#define m4W ' '
#define b1P '+' 
#define g8C '*' 
#define j9H '-' 
#define r7P '.' 
#define o4O 'v'
#define n1R 'w'
#define h5Fg '?'
#define y0G "t:"
#define v5V d1X
#define o8E 220
#define p1B 20
#define t1J 3
#define i2E "3"
#define c4S 3
#define r5L "3"
x7H *c8E = NULL;
x7H *u6E = NULL;
x7H *l7X = NULL;
x7H *d9H = NULL;
STRPTR n1T = y0G;
STRPTR c6M = NULL;
STRPTR h9P = NULL;
unsigned y4M = 0;
size_t x9V = t1J;
size_t d3J = c4S;
BOOL e2Kh = TRUE;
BOOL y2G = TRUE;
BOOL x1L = FALSE;
BOOL i4K = TRUE;
BOOL z3P = FALSE;
BOOL j1L = FALSE;
BOOL v3P = FALSE;
BOOL a8M = FALSE;
#define c2Q 1024
static STRPTR l7Xg = NULL;
static STRPTR s6O = NULL;
#ifdef AMIGA
const char c0Cn[] = i8I;
#endif
void j9J(const char *format,...)
{
va_list j5P;
va_start(j5P, format);
vfprintf(stderr, format, j5P);
va_end(j5P);
}
void d3R(const char *format,...)
{
va_list j5P;
va_start(j5P, format);
if (!v3P)
{
vfprintf(stderr, format, j5P);
}
va_end(j5P);
}
void u4Ip(const char *format,...)
{
va_list j5P;
va_start(j5P, format);
if (!j1L)
{
vprintf(format, j5P);
}
va_end(j5P);
}
static BOOL j7V[128];
static BOOL s4Gh[128];
static BOOL u0C[128];
static BOOL v1P[128];
BOOL a4S(int a0C)
{
if ((a0C >= 128) || (a0C < 0))
{
return FALSE;
}
else
{
return j7V[a0C];
}
}
BOOL r1J(int a0C)
{
if ((a0C >= 128) || (a0C < 0))
{
return FALSE;
}
else
{
return s4Gh[a0C];
}
}
BOOL w0M(int a0C)
{
if ((a0C >= 128) || (a0C < 0))
{
return FALSE;
}
else
{
return v1P[a0C];
}
}
BOOL v3X(int a0C)
{
if ((a0C >= 128) || (a0C < 0))
{
return FALSE;
}
else
{
return u0C[a0C];
}
}
BOOL w2Q(STRPTR r7V)
{
if (r1J(r7V[0]))
{
return TRUE;
}
else
{
return FALSE;
}
}
VOID z7Z(VOID)
{
int i = 0;
while (i < 128)
{
BOOL a4S = FALSE;
BOOL r1J = FALSE;
BOOL w0M = FALSE;
BOOL v3X = FALSE;
if (strchr("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"_", i))
{
a4S = TRUE;
}
else
{
if (strchr("0123456789", i))
{
r1J = TRUE;
}
else if (strchr(" \t\r\n\f", i))
{
v3X = TRUE;
}
}
if (strchr("0123456789abcdefABCDEFxXlL", i))
{
w0M = TRUE;
}
j7V[i] = a4S;
s4Gh[i] = r1J;
v1P[i] = w0M;
u0C[i] = v3X;
i += 1;
}
}
typedef char n3B;
#define l5P 0
#define u2Y 1
#define m8S 1
#define d3F 1
#define t9J 2 
#define i8M 3 
#define z3B 4 
n3B c0C(STRPTR f7Z)
{
n3B c6Q = l5P;
STRPTR s8M = NULL;
STRPTR o2Ol = f7Z;
while (o2Ol[0])
{
switch (o2Ol[0])
{
case '/':
case ':':
case '.':
s8M = o2Ol + 1;
break;
}
o2Ol += 1;
}
if (s8M)
{
if (!x9D(s8M, "c")
|| !x9D(s8M, "h"))
{
c6Q = t9J;
}
else if (!x9D(s8M, "c++")
|| !x9D(s8M, "cpp")
|| !x9D(s8M, "cc")
|| !x9D(s8M, "cxx"))
{
c6Q = i8M;
}
else if (!x9D(s8M, "java")
|| !x9D(s8M, "jav")
|| !x9D(s8M, "j"))
{
c6Q = z3B;
}
}
return c6Q;
}
STRPTR y0E(n3B c6Q)
{
STRPTR text = NULL;
switch (c6Q)
{
case l5P:
text = "Unknown";
break;
case t9J:
text = "C";
break;
case i8M:
text = "C++";
break;
case z3B:
text = "Java";
break;
}
return text;
}
STRPTR l7V(LONG w8I, STRPTR d3B, STRPTR c6C)
{
if (w8I == 1)
{
return d3B;
}
else
{
return c6C;
}
}
BOOL q4S(STRPTR f7Z)
{
BOOL ok = FALSE;
#ifdef AMIGA
BPTR t5D = Lock(f7Z, ACCESS_READ);
if (!t5D)
{
STRPTR u0Q = e0O(f7Z);
STRPTR h3X = PathPart(u0Q);
BOOL l9Pg = FALSE;
if (h3X[-1] == ':')
{
l9Pg = TRUE;
}
if (l9Pg)
{
ok = TRUE;
}
else
{
if (h3X != u0Q)
{
h3X[0] = '\0';
ok = q4S(u0Q);
}
else
{
ok = TRUE;
}
}
if (ok)
{
t5D = CreateDir(f7Z);
if (t5D && !j1L)
{
u4Ip("  %s (created)\n", f7Z);
}
}
else
{
g8M("cannot create directory `%s'", f7Z);
}
y8Mj(u0Q);
}
else
{
ok = TRUE;
}
if (t5D)
{
UnLock(t5D);
}
#else
ok = TRUE;
#endif
return ok;
}
BOOL z7Dg(STRPTR l7T)
{
BOOL ok = FALSE;
#ifdef AMIGA
STRPTR u0Q = e0O(l7T);
STRPTR h3X = PathPart(u0Q);
h3X[0] = '\0';
ok = q4S(u0Q);
y8Mj(u0Q);
#else
ok = TRUE;
#endif
return ok;
}
FILE *p3H(STRPTR f7Z, STRPTR w8C)
{
FILE *j5R = NULL;
g8M("open \"%s\", mode=%s\n", f7Z, w8C);
if (!strcmp(w8C, "w"))
{
z7Dg(f7Z);
}
j5R = fopen(f7Z, w8C);
if (j5R == NULL)
{
STRPTR f3N = "input";
if (!strcmp(w8C, "w"))
{
f3N = "output";
}
j9J("cannot open \"%s\" for %s: %s\n",
f7Z, f3N, strerror(errno));
}
return j5R;
}
VOID n9Pc(FILE * j5R, STRPTR l7T)
{
g8M("close \"%s\"\n", l7T);
if (j5R)
{
int old_errno = errno;
if (fclose(j5R) != 0)
{
j9J("error closing \"%s\"\n", l7T);
}
else
{
g8M("(after fclose \"%s\")", l7T);
if (errno != old_errno)
{
j9J("bug detected in compiler library: "
"faulty implementation of fclose()");
}
}
}
}
STRPTR o2M(STRPTR l7T)
{
STRPTR m8I = NULL;
FILE *j5R = p3H(l7T, "rb");
if (j5R)
{
long d7Z = 0;
size_t u4I = 0;
size_t b5Pg = 0;
fseek(j5R, 0L, SEEK_END);
d7Z = ftell(j5R);
u4I = (size_t) d7Z;
m8I = (STRPTR) c8Y(u4I + 1);
if (m8I)
{
fseek(j5R, 0L, SEEK_SET);
b5Pg = fread((void *) m8I, 1, u4I, j5R);
if (b5Pg == (size_t) u4I)
{
m8I[u4I] = '\0';
}
else
{
l5D(m8I);
}
}
else
{
}
n9Pc(j5R, l7T);
}
return m8I;
}
int t1H(FILE * j5R, STRPTR l7T)
{
int a0C = EOF;
if (!errno && !feof(j5R))
{
a0C = fgetc(j5R);
if (errno)
{
j9J("cannot read \"%s\": %s\n",
l7T, strerror(errno));
}
}
return a0C;
}
STRPTR i6Y(char *u6C, int u0Qh, FILE * j5R, STRPTR l7T)
{
STRPTR q6U = NULL;
if (!errno)
{
q6U = fgets(u6C, u0Qh, j5R);
if (q6U)
{
size_t e8I = strlen(q6U);
size_t l1P = 0;
while ((e8I >= 1)
&& ((q6U[e8I - 1] == '\n')
|| (q6U[e8I - 1] == '\r'))
)
{
q6U[strlen(q6U) - 1] = '\0';
l1P += 1;
e8I = strlen(q6U);
}
if (!l1P && (strlen(q6U) == ((size_t) (u0Qh - 1))))
{
j9J("cannot read \"%s\":"
" line must be shorter than %lu\n",
l7T, u0Qh - 1);
exit(EXIT_FAILURE);
}
}
else if (errno)
{
j9J("cannot read \"%s\": %s\n",
l7T, strerror(errno));
}
}
return q6U;
}
int s6C(int a0C, FILE * j5R, STRPTR l7T)
{
int x7P = EOF;
if (!errno && j5R)
{
x7P = fputc(a0C, j5R);
if (errno)
{
j9J("cannot write \"%s\": %s\n",
l7T, strerror(errno));
}
else
{
m0Q();
a0Gr('`');
a0Gr(x7P);
a0Gr('\'');
d3Z();
}
}
return x7P;
}
int r3J(const char *s, FILE * j5R, STRPTR l7T)
{
int v3Lg = EOF;
if (!errno && j5R)
{
v3Lg = fputs(s, j5R);
if (errno)
{
j9J("cannot write \"%s\": %s\n",
l7T, strerror(errno));
}
else
{
int i = 0;
m0Q();
a0Gr('`');
while (s[i])
{
a0Gr(s[i]);
i += 1;
}
a0Gr('\'');
d3Z();
}
}
return v3Lg;
}
STRPTR g2O(STRPTR u6C, size_t j5V, FILE * o0Er, STRPTR a2E)
{
#define i8U 1
#define f9Z 2
#define u4O 3
#define z5T 4
int t7P = t1H(o0Er, a2E); 
size_t v7B = 1; 
int l9X = i8U; 
STRPTR r7V = u6C; 
r7V[v7B - 1] = t7P;
if (t7P == EOF)
{
v7B = 0;
}
else if (r1J(t7P))
{
l9X = u4O;
}
else if (a4S(t7P))
{
l9X = f9Z;
}
else if (v3X(t7P))
{
l9X = z5T;
}
while (l9X != i8U)
{
t7P = t1H(o0Er, a2E);
if (t7P == EOF)
{
l9X = i8U;
}
else
{
v7B += 1;
r7V[v7B - 1] = t7P;
if (v7B == j5V)
{
j9J("words in text must be shorter than %lu\n", j5V);
exit(EXIT_FAILURE);
}
else if (l9X == f9Z)
{
if (!(a4S(t7P) || (r1J(t7P))))
{
l9X = i8U;
}
}
else if (l9X == u4O)
{
if (!(w0M(t7P)))
{
l9X = i8U;
}
}
else if (l9X == z5T)
{
if (!(v3X(t7P)))
{
l9X = i8U;
}
}
else
{
f3F("unhandled state");
}
}
}
if ((t7P != EOF) && (v7B > 1))
{
ungetc(t7P, o0Er);
v7B -= 1;
}
r7V[v7B] = '\0';
if ((v7B == 0) || (errno != 0))
{
r7V = NULL;
}
return r7V;
}
VOID x7T(BOOL j5H, int a0C, FILE * j5R, STRPTR l7T)
{
if (j5H)
{
s6C(a0C, j5R, l7T);
}
}
VOID u8Q(FILE * o0Er, STRPTR a2E, FILE * q4I, STRPTR e6A, char t5P)
{
BOOL c2I = FALSE;
BOOL y8A = FALSE;
g8M("writing string/character constant");
while (!feof(o0Er) && !y8A)
{
int ch = t1H(o0Er, a2E);
if (ch != EOF)
{
s6C(ch, q4I, e6A);
if (!c2I)
{
if (ch == '\\')
{
c2I = TRUE;
}
else if (ch == t5P)
{
y8A = TRUE;
}
}
else
{
c2I = FALSE;
}
}
else
{
g8M("unexpected EOF");
}
}
g8M("(end of constant)");
}
VOID x7Ta(FILE * o0Er, STRPTR a2E, FILE * q4I, STRPTR e6A)
{
BOOL g0Q = FALSE;
BOOL y8A = FALSE;
g8M("handling C comment");
x7T(!e2Kh, '/', q4I, e6A);
x7T(!e2Kh, '*', q4I, e6A);
while (!feof(o0Er) && !y8A)
{
int ch = t1H(o0Er, a2E);
if (ch != EOF)
{
BOOL p1V = !e2Kh;
if (z3P && (ch == '\n'))
{
p1V = TRUE;
}
x7T(p1V, ch, q4I, e6A);
if (g0Q)
{
if (ch == '/')
{
y8A = TRUE;
}
else if (ch != '*')
{
g0Q = FALSE;
}
}
else if (ch == '*')
{
g0Q = TRUE;
}
}
else
{
g8M("unexpected EOF");
}
}
if (e2Kh)
{
g8M("ungetting blank");
ungetc(' ', o0Er);
}
g8M("(end of C comment)");
}
VOID f3P(FILE * o0Er, STRPTR a2E, FILE * q4I, STRPTR e6A)
{
BOOL y8A = FALSE;
g8M("handling C++ comment");
x7T(!e2Kh, '/', q4I, e6A);
x7T(!e2Kh, '/', q4I, e6A);
while (!feof(o0Er) && !y8A)
{
int ch = t1H(o0Er, a2E);
if (ch != EOF)
{
BOOL p1V = !e2Kh;
if (z3P && (ch == '\n'))
{
p1V = TRUE;
}
x7T(p1V, ch, q4I, e6A);
if ((ch == '\n') || (ch == '\r'))
{
y8A = TRUE;
}
}
}
if (e2Kh)
{
g8M("ungetting blank");
ungetc(' ', o0Er);
}
g8M("(end of C++ comment)");
}
VOID g0O(STRPTR t9Du, FILE * q4I, STRPTR e6A, BOOL f9D)
{
if (f9D)
{
s6C('/', q4I, e6A);
}
if (y2G)
{
int y4Mt = ' ';
BOOL s4M = FALSE; 
BOOL h9B = FALSE; 
BOOL p7F = FALSE;
ULONG e2I = 0;
size_t i = 0;
while (t9Du[i] && !p7F)
{
switch (t9Du[i])
{
case '\n':
h9B = TRUE;
e2I += 1;
break;
case '\r':
s4M = TRUE;
break;
}
if (s4M && h9B)
{
p7F = TRUE;
}
i += 1;
}
if (s4M || h9B)
{
y4Mt = '\n';
}
if ((e2I == 0) || (!z3P))
{
e2I = 1;
}
i = 0;
do
{
s6C(y4Mt, q4I, e6A);
i += 1;
}
while (i < e2I);
}
else
{
r3J(t9Du, q4I, e6A);
}
}
x9J *j1P(const STRPTR f7Z, char l7H)
{
x9J *r7V = i8W(f7Z);
if (r7V == NULL)
{
STRPTR t9T = NULL;
r7V = (x9J *) c8Y(sizeof(x9J));
r7V->r5N = (STRPTR) c8Y(strlen(f7Z) + 1);
strcpy(r7V->r5N, f7Z);
t9T = strchr(r7V->r5N, '=');
if (t9T)
{
if (t9T)
{
t9T[0] = '\0';
if (l7H == b1P)
{
t9T = NULL;
}
else
{
t9T += 1;
}
}
}
r7V->u6C = t9T;
r7V->w8C = l7H;
r7V->j7Pq = 0;
if (!j3D(&u8Qh, r7V, r7V->r5N, NULL))
{
g2W((u8Ol) r7V);
}
}
return r7V;
}
BOOL s2El(FILE * q4I, STRPTR e6A, STRPTR c6M)
{
BOOL ok = TRUE;
if (c6M)
{
if (r3J(c6M, q4I, e6A) == EOF)
{
ok = FALSE;
}
}
else
{
}
return ok;
}
STRPTR f3R(STRPTR h9P)
{
STRPTR c6M = o2M(h9P);
if (c6M == NULL)
{
j9J("cannot read prefix text: %s", strerror(errno));
}
return c6M;
}
BOOL r5F(STRPTR a2E, STRPTR e6A, char l7H)
{
#define n3R 200
static char s6O[n3R];
BOOL ok = TRUE;
FILE *o0Er = p3H(a2E, "r");
FILE *q4I = NULL;
BOOL f9D = FALSE;
if (o0Er && e6A)
{
q4I = p3H(e6A, "w");
if (q4I)
{
ok = s2El(q4I, e6A, c6M);
}
else
{
ok = FALSE;
}
}
if (o0Er && ok)
{
STRPTR t3J = NULL;
STRPTR p5J = a2E;
ok = TRUE;
if (e6A)
{
p5J = e6A;
}
u4Ip("  %s\n", p5J);
do
{
BOOL w2G = FALSE;
t3J = g2O(&s6O[0], n3R,
o0Er, a2E);
if (t3J)
{
if (v3X(t3J[0]))
{
g0O(t3J, q4I, e6A,
f9D);
}
else if (t3J[1] == '\0')
{
BOOL k0Ix = TRUE;
if ((t3J[0] == '/') || f9D)
{
k0Ix = FALSE;
}
if (f9D)
{
switch (t3J[0])
{
case '*':
x7Ta(o0Er, a2E,
q4I, e6A);
break;
case '/':
f3P(o0Er, a2E,
q4I, e6A);
break;
default:
s6C('/', q4I, e6A);
r3J(t3J, q4I, e6A);
}
}
else
{
if (k0Ix)
{
r3J(t3J, q4I, e6A);
}
switch (t3J[0])
{
case '"':
case '\'':
u8Q(o0Er, a2E,
q4I, e6A,
t3J[0]);
break;
case '/':
w2G = TRUE;
break;
default:
break;
}
}
}
else
{
if (f9D)
{
s6C('/', q4I, e6A);
}
if ((strlen(t3J) >= d3J)
&& !w2Q(t3J))
{
if (l7H != n1R)
{
x9J *r7V = j1P(t3J, l7H);
r7V->j7Pq += 1;
if ((r7V->w8C == j9H)
&& (r7V->j7Pq == 1))
{
g8M("`%s' ignored, "
"but counted.",
t3J);
}
}
else
{
x9J *r3V = i8W(t3J);
if (r3V)
{
STRPTR e8A = t3J;
if (r3V->u6C)
{
switch (r3V->w8C)
{
case b1P:
case m4W:
case g8C:
e8A = r3V->u6C;
g8M("`%s' -> `%s'",
t3J, e8A);
break;
case j9H:
case r7P:
break;
default:
f3F("unknown mode");
}
}
r3J(e8A, q4I,
e6A);
}
else
{
j9J("cannot vahunz: source files must "
"remain unchanged between passes\n"
"(word `%s' has been added)", t3J);
ok = FALSE;
}
}
}
else
{
r3J(t3J, q4I, e6A);
}
}
if (w2G)
{
f9D = TRUE;
}
else
{
f9D = FALSE;
}
}
else if (errno != 0)
{
g8M("error in read_word()");
ok = FALSE;
}
}
while (t3J && ok);
n9Pc(o0Er, a2E);
}
else
{
ok = FALSE;
}
n9Pc(q4I, e6A);
return ok;
}
BOOL i4Y(ULONG * q8U, STRPTR c8E, char w8C)
{
BOOL ok = FALSE;
FILE *p1J = p3H(c8E, "r");
x7H *z7H = s6Q(0);
if (p1J)
{
STRPTR m2O = NULL;
do
{
m2O = i6Y(l7Xg, c2Q,
p1J, c8E);
if (m2O && m2O[0])
{
STRPTR e6A = NULL;
if (w8C == n1R)
{
char k0C = n9B(n1T);
d1V(z7H, n1T);
if ((k0C != '/')
&& (k0C != ':'))
{
v9N(z7H, '/');
}
o0S(z7H, m2O);
e6A = n5H(z7H);
}
ok = r5F(m2O, e6A, w8C);
g8M("(after scan_file())");
if (q8U)
{
*q8U = *q8U + 1;
}
}
}
while (m2O);
n9Pc(p1J, c8E);
}
p1X(z7H);
return ok;
}
struct z7J
{
FILE *y8I;
STRPTR z7D;
FILE *c8C;
STRPTR l7X;
size_t h5R;
size_t r9X;
size_t s2W;
};
typedef struct z7J k6U;
VOID z7Zo(h7L * r3V, void *f3Ng)
{
x9J *b1X = (x9J *) r3V;
if (!errno)
{
STRPTR f7Z = NULL;
FILE *j5R = NULL;
k6U *d9Pe = (k6U *) f3Ng;
if (b1X->j7Pq || !a8M)
{
switch (b1X->w8C)
{
case m4W:
case g8C:
case b1P:
j5R = d9Pe->y8I;
f7Z = d9Pe->z7D;
break;
case j9H:
j5R = d9Pe->c8C;
f7Z = d9Pe->l7X;
break;
case r7P:
case o4O:
break;
default:
f3F("unknown vahunz-mode");
break;
}
}
if (f7Z)
{
fputc(b1X->w8C, j5R);
fputs(b1X->r5N, j5R);
if (b1X->u6C)
{
BOOL p3F = TRUE;
if (b1X->w8C == b1P)
{
p3F = x1L;
}
if (p3F)
{
fputc('=', j5R);
fputs(b1X->u6C, j5R);
}
}
fputc('\n', j5R);
if (errno)
{
j9J("cannot write \"%s\": %s\n",
f7Z, strerror(errno));
}
}
}
}
BOOL q2I(STRPTR z7D, STRPTR l7X)
{
BOOL ok = FALSE;
k6U d9Pe;
errno = 0;
memset(&d9Pe, 0, sizeof(k6U));
d9Pe.z7D = z7D;
d9Pe.y8I = p3H(z7D, "w");
d9Pe.l7X = l7X;
d9Pe.c8C = p3H(l7X, "w");
if (errno == 0)
{
l1J(&u8Qh, z7Zo, &d9Pe);
}
if (errno == 0)
{
ok = TRUE;
}
n9Pc(d9Pe.y8I, z7D);
n9Pc(d9Pe.c8C, l7X);
return ok;
}
BOOL s4Qp(STRPTR l7T)
{
BOOL i4W = FALSE;
FILE *z7B = NULL;
size_t r3D = 0;
z7B = fopen(l7T, "r");
if (z7B)
{
STRPTR q6U = NULL;
u4Ip("  %s\n", l7T);
i4W = TRUE;
do
{
STRPTR r7V = NULL;
char w8C = h5Fg;
q6U = i6Y(l7Xg, c2Q,
z7B, l7T);
r3D += 1;
if (q6U && q6U[0])
{
w8C = q6U[0];
r7V = q6U + 1;
if ((w8C != b1P)
&& (w8C != m4W)
&& (w8C != g8C)
&& (w8C != j9H))
{
int y4W = w8C;
if (w8C < 32)
{
y4W = h5Fg;
}
d3R("warning: ignoring unknown vahunz-mode "
"`%c' (0x%02x) in line %lu\n",
y4W, w8C, r3D);
}
else if (j1P(r7V, w8C) == NULL)
{
if (w8C != j9H)
{
d3R("warning: ignoring duplicate name `%s' "
"in line %lu\n",
r7V, r3D);
}
}
else
{
}
}
}
while (q6U);
n9Pc(z7B, l7T);
}
else
{
errno = 0;
}
return i4W;
}
static char s2E(STRPTR set)
{
return ((char) set[rand() % strlen(set)]);
}
static VOID g0C(STRPTR u6C, size_t * h1J)
{
char u0M = 0;
if (*h1J == o8E)
{
f3F("name got too long");
}
switch (*h1J % 3)
{
case 0:
u0M = s2E("abcdefghijklmnopqrstuvwxyz");
break;
case 1:
u0M = s2E("1234567890");
break;
case 2:
u0M = s2E("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
break;
default:
f3F("bad modulo");
break;
}
u6C[*h1J] = u0M;
*h1J = *h1J + 1;
u6C[*h1J] = '\0';
}
static VOID c0A(u8Ol r3V, VOID * f3Ng)
{
x9J *r7V = (x9J *) r3V;
ULONG *u8O = (ULONG *) f3Ng;
x9J *u6C = NULL;
BOOL o8Y = FALSE; 
BOOL j1T = FALSE;
if (r7V->w8C == b1P)
{
static char u2C[o8E]; 
size_t l1X = 0;
size_t g8U = strlen(r7V->r5N);
STRPTR w6C = NULL;
*u8O = *u8O + 1;
while (l1X < x9V)
{
g0C(u2C, &l1X);
}
do
{
if (i8W(u2C) == NULL)
{
j1T = TRUE;
}
if (!j1T)
{
g8M("vahunzed name `%s' already exists", u2C);
g0C(u2C, &l1X);
}
}
while (!j1T);
w6C = (STRPTR) c8Y(g8U + l1X + 2);
strcpy(w6C, r7V->r5N);
w6C[g8U] = '\0';
strcpy(w6C + g8U + 1, u2C);
l5D(r7V->r5N);
r7V->r5N = w6C;
r7V->u6C = w6C + g8U + 1;
u6C = (x9J *) c8Y(sizeof(x9J));
u6C->r5N = e0O(u2C);
u6C->u6C = NULL;
u6C->w8C = o4O;
u6C->j7Pq = 0;
o8Y = j3D(&u8Qh, u6C, u2C, NULL);
if (!o8Y)
{
f3F("insert failed");
}
l7B((u8Ol) r7V, "insert");
}
}
VOID c8A(VOID)
{
ULONG u8O = 0;
l1J(&u8Qh, c0A, &u8O);
u4Ip("  %lu %s vahunzed\n", u8O,
l7V(u8O, "name", "names"));
}
static VOID k8Q(const char *format,...)
{
va_list j5P;
va_start(j5P, format);
fprintf(stderr, "cannot handle command line parameters: ");
vfprintf(stderr, format, j5P);
fprintf(stderr, "\n");
va_end(j5P);
}
static int j1D(char **u6C, char *f7Z,
char *q0U, char *l9N,
char *o6C)
{
int y0O = 0;
char *a2Eh = NULL;
if (!strncmp(f7Z, l9N, strlen(f7Z)))
{
a2Eh = f7Z;
}
else if (!strncmp(q0U, l9N, strlen(q0U)))
{
a2Eh = q0U;
}
if (a2Eh)
{
if (strcmp(a2Eh, l9N))
{
*u6C = l9N + strlen(a2Eh);
if (((*u6C)[0]) == '=')
{
(*u6C)++;
}
y0O = 1;
}
else if (o6C)
{
*u6C = o6C;
y0O = 2;
}
else
{
k8Q("parameter %s must have a value", a2Eh);
y0O = -1;
}
}
if (y0O > 0)
{
g8M("  %s=`%s'", q0U, *u6C);
}
return (y0O);
}
static int g8K(BOOL * u6C, char *f7Z,
char *q0U, char *l9N, BOOL value)
{
int y0O = 0;
char *a2Eh = NULL;
if (!strncmp(f7Z, l9N, strlen(f7Z)))
{
a2Eh = f7Z;
}
else if (!strncmp(q0U, l9N, strlen(q0U)))
{
a2Eh = q0U;
}
if (a2Eh)
{
*u6C = value;
g8M("  flag: %s=%d", q0U, *u6C);
y0O = 1;
}
return (y0O);
}
BOOL w2I(int k0U, char *l9N[])
{
BOOL ok = TRUE;
static STRPTR p5H =
"Usage: " d1X " [options]\n"
"\n"
"Possible options are:\n"
"--help, -h\n"
"    View this message and exit\n"
"--base-name={name}, -b\n"
"    Base name for supporting files "
" (default: " v5V ")\n"
"--comment, -c\n"
"    Preserve comments\n"
"--indent, -i\n"
"    Preserve indention\n"
"--line, -l\n"
"    Preserve line numbers\n"
"--name-length={number}, -n\n"
"    Minimum length for names taken into account for vahunzation"
" (default: " r5L ")\n"
"--no-unused, -u\n"
"    Do not store unused names in dictionary\n"
"--no-warning, -w\n"
"    Suppress warning messages\n"
"--output={directory}, -o\n"
"    Directory where to store vahunzed files"
" (default: " y0G ")\n"
"--prefix-file, -p\n"
"    File containing prefix text added to all vahunzed files\n"
"--quiet, -q\n"
"    Do not tell what is going on\n"
"--random-seed={number}, -r\n"
"    Random seed for vahunzed names (default: current time)\n"
"--store, -s\n"
"    Store vahunzed names in dictionary\n"
"--vahunz-length={number}, -v\n"
"    Minimum length for vahunzed names"
" (default: " i2E ")\n";
int i = 1;
BOOL i8E = FALSE;
STRPTR g0I = v5V;
STRPTR y4M = NULL;
STRPTR u2E = NULL;
STRPTR a6I = NULL;
unsigned d5X = 0;
while ((i < k0U) && ok)
{
char *e0Uh = l9N[i];
char *o6C = NULL;
int d1Xa = 0;
g8M("arg%2d=`%s'", i, e0Uh);
if (i < (k0U - 1))
{
o6C = l9N[i + 1];
}
else
{
o6C = NULL;
}
d1Xa = j1D(&g0I, "-b", "--base-name",
e0Uh, o6C);
if (!d1Xa)
{
d1Xa = j1D(&n1T, "-o", "--output",
e0Uh, o6C);
}
if (!d1Xa)
{
d1Xa = j1D(&y4M, "-r", "--random-seed",
e0Uh, o6C);
}
if (!d1Xa)
{
d1Xa = j1D(&u2E,
"-v", "--vahunz-length",
e0Uh, o6C);
}
if (!d1Xa)
{
d1Xa = j1D(&a6I,
"-n", "--name-length",
e0Uh, o6C);
}
if (!d1Xa)
{
d1Xa = j1D(&h9P, "-p", "--prefix-file",
e0Uh, o6C);
}
if (!d1Xa)
{
d1Xa = g8K(&i8E, "?", "-?",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&i8E, "-h", "--help",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&e2Kh, "-c", "--comment",
e0Uh, FALSE);
}
if (!d1Xa)
{
d1Xa = g8K(&y2G, "-i", "--indent",
e0Uh, FALSE);
}
if (!d1Xa)
{
d1Xa = g8K(&z3P, "-l", "--line",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&j1L, "-q", "--quiet",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&x1L, "-s", "--store",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&v3P, "-w", "--no-warning",
e0Uh, TRUE);
}
if (!d1Xa)
{
d1Xa = g8K(&a8M, "-u", "--no-unused",
e0Uh, TRUE);
}
if (d1Xa == 0)
{
k8Q("unknown parameter \"%s\"; use \"--help\" for "
"a list of possible parameters", e0Uh);
ok = FALSE;
}
else if (d1Xa < 0)
{
ok = FALSE;
}
else
{
i += d1Xa;
}
}
if ((strlen(n1T) == 0)
|| !strcmp(n1T, ".")
|| !strcmp(n1T, "./"))
{
k8Q("setting output directory to "
"\"%s\" would replace original",
n1T);
ok = FALSE;
}
if (ok && y4M)
{
STRPTR o2U = NULL;
d5X = strtoul(y4M, &o2U, 0);
if (!o2U && o2U[0])
{
k8Q("--random-seed must be a number greater "
"than 0");
ok = FALSE;
}
}
else
{
d5X = (unsigned) time(NULL);
}
if (ok && a6I)
{
STRPTR o2U = NULL;
d3J = (size_t) strtoul(a6I,
&o2U, 0);
if ((!o2U && o2U[0]) || (d3J > 0))
{
k8Q("--name-length must be a number greater "
"than 0");
ok = FALSE;
}
}
if (ok && u2E)
{
STRPTR o2U = NULL;
x9V = (size_t) strtoul(u2E,
&o2U, 0);
if (!o2U && o2U[0])
{
ok = FALSE;
}
else if ((x9V < t1J)
|| (x9V > (o8E
- p1B)))
{
ok = FALSE;
}
if (!ok) {
k8Q("--minimum-length must be a number "
"between %lu and %lu",
t1J,
o8E - p1B);
}
}
if (ok && (i8E || !j1L))
{
FILE *l7Z = stdout;
fprintf(l7Z,
"%s - Make source code un-/more legible.\n"
"Version %d.%d (%s), (C) Thomas Aglassinger 1998,99\n\n",
d1X, f3H, n1Z, k2C);
if (i8E)
{
fprintf(l7Z, "%s", p5H);
fprintf(l7Z, "\nFor more information, see "
"http://www.giga.or.at/~agi/vahunz/\n");
ok = FALSE;
}
}
if (ok)
{
srand(d5X);
d1V(c8E, g0I);
o0S(c8E, ".files");
d1V(u6E, g0I);
o0S(u6E, ".names");
d1V(l7X, g0I);
o0S(l7X, ".ignore");
d1V(d9H, g0I);
o0S(d9H, ".keywords");
}
return ok;
}
VOID s0K(const STRPTR keyword[])
{
int i = 0;
while (keyword[i])
{
j1P(keyword[i], r7P);
i += 1;
}
}
VOID j5T(n3B c6Q)
{
if (!s4Qp(n5H(d9H)))
{
if ((c6Q == t9J) || (c6Q == i8M))
{
s0K(k6M);
if (c6Q == i8M)
{
s0K(z3H);
}
}
else if (c6Q == z3B)
{
s0K(l5B);
}
else
{
f3F("language unsupported");
}
}
}
BOOL m6O(STRPTR c8E)
{
n3B c6Q = l5P;
BOOL ok = FALSE;
FILE *p1J = p3H(c8E, "r");
if (p1J)
{
STRPTR y8K = NULL;
ok = TRUE;
do
{
n3B n1L = l5P;
y8K = i6Y(l7Xg, c2Q,
p1J, c8E);
if (y8K && strlen(y8K))
{
n1L = c0C(y8K);
if (n1L == l5P)
{
j9J("%s: language unknown\n",
y8K);
ok = FALSE;
}
else if (n1L != c6Q)
{
if (c6Q == l5P)
{
c6Q = n1L;
}
else if ((
(c6Q == t9J)
||
(c6Q == i8M)
)
&&
(
(n1L == t9J)
||
(n1L == i8M)))
{
c6Q = i8M;
}
else
{
j9J("%s: conflicts with previous language `%s'\n",
y8K, y0E(c6Q));
ok = FALSE;
}
}
}
}
while ((y8K != NULL) && ok);
n9Pc(p1J, c8E);
}
else
{
}
if (ok)
{
u4Ip("using `%s' as language\n\n",
y0E(c6Q));
if ((c6Q = t9J)
|| (c6Q = i8M)
|| (c6Q = z3B))
{
z7Z();
e2Kh = e2Kh;
y2G = y2G;
i4K = FALSE;
}
else
{
f3F("language unsupported");
}
j5T(c6Q);
ok = TRUE;
}
return ok;
}
BOOL s6A(size_t u0Qh)
{
fputs("\n*** out of memory\n\n", stderr);
exit(EXIT_FAILURE);
return (FALSE); 
}
VOID g2M(VOID)
{
g8M("cleanup\n");
p1X(l7X);
p1X(u6E);
p1X(d9H);
p1X(c8E);
l5D(c6M);
l5D(s6O);
l5D(l7Xg);
#if u0Y
v3Z(&u8Qh, g2W);
d9N();
#endif
}
int main(int argc, char *argv[])
{
int r1P = EXIT_FAILURE;
errno = 0;
k0Cr = s6A;
q6G(&u8Qh, f7X, 0);
l7Xg = (STRPTR) c8Y(c2Q);
s6O = (STRPTR) c8Y(c2Q);
c8E = s6Q(0);
d9H = s6Q(0);
u6E = s6Q(0);
l7X = s6Q(0);
if (w2I(argc, argv))
{
BOOL ok = FALSE;
BOOL m4A = FALSE;
BOOL c2S = FALSE;
char n5N = g8C;
STRPTR z5R = "updating";
ok = m6O(n5H(c8E));
if (ok)
{
u4Ip("reading existing files\n");
if (h9P != NULL)
{
c6M = o2M(h9P);
if (c6M != NULL)
{
u4Ip("  %s\n", h9P);
}
else
{
ok = FALSE;
}
}
}
if (ok)
{
ok = r5F(n5H(c8E), NULL,
j9H);
}
if (ok)
{
c2S = s4Qp(n5H(l7X));
m4A = s4Qp(n5H(u6E));
if (!m4A)
{
z5R = "building";
n5N = m4W;
}
u4Ip("\n%s dictionaries\n", z5R);
ok = i4Y(NULL, n5H(c8E), n5N);
}
if (ok && m4A)
{
u4Ip("\nbuilding vahunzed dictionary in memory\n");
c8A();
}
if (ok)
{
u4Ip("\nwriting dictionaries\n");
ok = q2I(n5H(u6E),
n5H(l7X));
if (ok)
{
if (m4A)
{
ULONG q8U = 0;
ok = FALSE;
u4Ip("\nwriting vahunzed files\n");
if (i4Y(&q8U,
n5H(c8E),
n1R))
{
u4Ip("\n%lu file%s vahunzed.\n", q8U,
l7V(q8U, "", "s"));
ok = TRUE;
}
}
else
{
u4Ip("\nThe dictionary has been written to `%s'\n"
"and should be modified now.\n",
n5H(u6E));
}
}
}
if (ok)
{
r1P = EXIT_SUCCESS;
}
}
g2M();
return r1P;
}