static struct symtab *
addstr(char *n)
{
NODE *p = block(NAME, NIL, NIL, FLOAT, 0, 0);
struct symtab *sp;
NODE *q;
struct attr *ap;
struct rstack *rp;
extern struct rstack *rpole;
p->n_type = ctype(ULONGLONG);
rpole = rp = bstruct(NULL, STNAME, NULL);
soumemb(p, loti, 0);
soumemb(p, hiti, 0);
q = dclstruct(rp);
sp = q->n_sp = lookup(addname(n), 0);
defid(q, TYPEDEF);
ap = attr_new(GCC_ATYP_MODE, 3);
ap->sarg(0) = addname("TI");
ap->iarg(1) = 0;
sp->sap = attr_add(sp->sap, ap);
nfree(q);
nfree(p);
return sp;
}
void
name_gather (void)
{
/* Buffer able to hold a single name. */
static struct name *buffer = NULL;
struct name_elt *ep;
if (same_order_option)
{
static int change_dir;
while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
change_dir = chdir_arg (xstrdup (ep->v.name));
if (ep)
{
free_name (buffer);
buffer = make_name (ep->v.name);
buffer->change_dir = change_dir;
buffer->next = 0;
buffer->found_count = 0;
buffer->matching_flags = matching_flags;
buffer->directory = NULL;
buffer->parent = NULL;
buffer->cmdline = true;
namelist = nametail = buffer;
}
else if (change_dir)
addname (0, change_dir, false, NULL);
}
else
{
/* Non sorted names -- read them all in. */
int change_dir = 0;
for (;;)
{
int change_dir0 = change_dir;
while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
change_dir = chdir_arg (xstrdup (ep->v.name));
if (ep)
addname (ep->v.name, change_dir, true, NULL);
else
{
if (change_dir != change_dir0)
addname (NULL, change_dir, false, NULL);
break;
}
}
}
}
static bool_t
addplayer (struct DATA *d, const char *s, player_t *idx)
{
const char *nameptr;
bool_t success = NULL != (nameptr = addname(d,s));
if (success) {
*idx = d->n_players++;
d->nm[d->nm_filled]->p[d->nm_idx++] = nameptr;
if (d->nm_idx == MAXNAMESxBLOCK) { // hit new block
struct NAMEBLOCK *nm;
d->nm_idx = 0;
d->nm_filled++;
success = NULL != (nm = memnew (sizeof(struct NAMEBLOCK)));
if (success) {
d->nm_allocated++;
}
d->nm[d->nm_filled] = nm;
}
}
return success;
}
/*
* Declare a namespace.
*/
void
dclns(NODE *attr, char *n)
{
struct symtab *sp;
struct attr *ap = gcc_attr_parse(attr);
if (cppdebug)printf("declaring namespace %s\n", n);
n = addname(n);
sp = sfind(n, nscur->sup);
while (sp != NULL) {
if (sp->sname == n && sp->sclass == NSPACE)
break;
sp = sfind(n, sp->snext);
}
if (sp == NULL) {
/* New namespace */
sp = getsymtab(n, 0);
sp->sclass = NSPACE;
INSSYM(sp);
}
nscur = sp;
if (cppdebug)printf("declaring namespace2 %s\n", nscur->sname);
sp->sap = attr_add(sp->sap, ap); /* XXX check attributes */
}
/*
* Put all builtin functions into the global symbol table.
*/
void
builtin_init()
{
const struct bitable *bt;
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
int i, d_debug;
d_debug = ddebug;
ddebug = 0;
for (i = 0; i < (int)(sizeof(bitable)/sizeof(bitable[0])); i++) {
bt = &bitable[i];
if ((bt->flags & BTGNUONLY) && xgnu99 == 0 && xgnu89 == 0)
continue; /* not in c99 universe, at least for now */
sp = lookup(addname(bt->name), 0);
if (bt->rt == 0 && (bt->flags & BTNORVAL) == 0)
cerror("function '%s' has no return type", bt->name);
p->n_type = INCREF(bt->rt) + (FTN-PTR);
p->n_df = memset(permalloc(sizeof(union dimfun)), 0,
sizeof(union dimfun));
p->n_sp = sp;
defid(p, EXTERN);
sp->soffset = i;
sp->sflags |= SBUILTIN;
}
nfree(p);
ddebug = d_debug;
}
/**
* \brief Get a list of Starlight Express cameras.
*
* \param device the type of devices we want to have listed
* \return a vector of strings that uniquely descript devices
*/
std::vector<std::string> QhyCameraLocator::getDevicelist(DeviceName::device_type device) {
std::vector<std::string> names;
// list all devices from the context
std::vector<usb::DevicePtr> d = context.devices();
std::vector<usb::DevicePtr>::const_iterator i;
for (i = d.begin(); i != d.end(); i++) {
usb::DevicePtr devptr = *i;
// try to open all devices, and check whether they have
// the right vendor id
try {
devptr->open();
try {
addname(names, devptr, device);
} catch (std::runtime_error& x) {
debug(LOG_DEBUG, DEBUG_LOG, 0, "found a non "
"QHY device: %s", x.what());
}
} catch (std::exception& x) {
std::string msg = stringprintf("cannot work with "
"device at bus=%d and addr=%d",
devptr->getBusNumber(),
devptr->getDeviceAddress());
debug(LOG_ERR, DEBUG_LOG, 0, msg.c_str());
}
}
// return the list of devices
return names;
}
void
bjobcode(void)
{
struct symtab *sp;
struct rstack *rp;
NODE *p, *q;
char *c;
/* amd64 names for some asm constant printouts */
astypnames[INT] = astypnames[UNSIGNED] = "\t.long";
astypnames[LONG] = astypnames[ULONG] = "\t.quad";
gp_offset = addname("gp_offset");
fp_offset = addname("fp_offset");
overflow_arg_area = addname("overflow_arg_area");
reg_save_area = addname("reg_save_area");
rp = bstruct(NULL, STNAME, NULL);
p = block(NAME, NIL, NIL, UNSIGNED, 0, 0);
soumemb(p, gp_offset, 0);
soumemb(p, fp_offset, 0);
p->n_type = VOID+PTR;
p->n_ap = NULL;
soumemb(p, overflow_arg_area, 0);
soumemb(p, reg_save_area, 0);
nfree(p);
q = dclstruct(rp);
c = addname("__builtin_va_list");
p = block(LB, bdty(NAME, c), bcon(1), INT, 0, 0);
p = tymerge(q, p);
p->n_sp = lookup(c, 0);
defid(p, TYPEDEF);
nfree(q);
nfree(p);
/* for the static varargs functions */
#define MKN(vn, rn, tp) \
{ vn = addname(rn); sp = lookup(vn, SNORMAL); \
sp->sclass = USTATIC; sp->stype = tp; }
MKN(gpnext, "__pcc_gpnext", FTN|LONG);
MKN(fpnext, "__pcc_fpnext", FTN|DOUBLE);
MKN(_1regref, "__pcc_1regref", FTN|VOID|(PTR<<TSHIFT));
MKN(_2regref, "__pcc_2regref", FTN|VOID|(PTR<<TSHIFT));
MKN(memref, "__pcc_memref", FTN|VOID|(PTR<<TSHIFT));
}
/*
* Do name mangling of a symbol table entry.
* The resulting name is saved in soname.
*/
char *
decoratename(struct symtab *sp, int type)
{
char *n;
#define QNM(m,s) case m: n = s; break
switch (type) {
QNM(NM_NEW,"_Znwm");
QNM(NM_NWA,"_Znam");
QNM(NM_DEL,"_ZdlPv");
QNM(NM_DLA,"_ZdaPv");
case NM_NORMAL: /* Defined in defid() */
break;
default:
uerror("missed mangling %d\n", type);
return "";
}
if (type != NM_NORMAL)
return addname(n);
/* special non-mangled cases:
* "C" linkage
* main() function
* variables outside namespaces and classes
*/
if (elnk == LINK_C || strcmp(sp->sname, "main") == 0 ||
(sp->sdown == spole && ISFTN(sp->stype) == 0)) {
n = exname(sp->sname);
return addname(n);
}
/* Compute the mangled name for other symbols */
nmptr = 0;
subptr = 0;
nmch('_'); nmch('Z');
if (sp->sdown != NULL) {
nmch('N');
recnpsh(sp->sdown);
}
pshsln(sp->sname);
if (sp->sdown != NULL)
nmch('E');
if (ISFTN(sp->stype) && sp->sdf->dfun)
pshargs(sp->sdf->dfun);
nmch(0);
return addname(nmblk);
}
static void
add_hierarchy_to_namelist (char *path, int device)
{
char *buffer = get_directory_contents (path, device);
{
struct name *name;
for (name = namelist; name; name = name->next)
if (strcmp (name->name, path) == 0)
break;
if (name)
name->dir_contents = buffer ? buffer : "\0\0\0\0";
}
if (buffer)
{
int name_length = strlen (path);
int allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
char *name_buffer = xmalloc ((size_t) (allocated_length + 1));
/* FIXME: + 2 above? */
char *string;
int string_length;
strcpy (name_buffer, path);
if (name_buffer[name_length - 1] != PATHSEP)
{
name_buffer[name_length++] = PATHSEP;
name_buffer[name_length] = '\0';
}
for (string = buffer; *string; string += string_length + 1)
{
string_length = strlen (string);
if (*string == 'D')
{
if (name_length + string_length >= allocated_length)
{
while (name_length + string_length >= allocated_length)
allocated_length += NAME_FIELD_SIZE;
name_buffer = (char *)
xrealloc (name_buffer, (size_t) (allocated_length + 1));
}
strcpy (name_buffer + name_length, string + 1);
addname (name_buffer);
add_hierarchy_to_namelist (name_buffer, device);
}
}
free (name_buffer);
}
}
void
gcc_init(void)
{
struct kw *kwp;
NODE *p;
TWORD t;
int i;
for (kwp = kw; kwp->name; kwp++)
kwp->ptr = addname(kwp->name);
for (i = 0; i < 4; i++) {
struct symtab *sp;
t = ctype(g77t[i]);
p = block(NAME, NIL, NIL, t, NULL, 0);
sp = lookup(addname(g77n[i]), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
}
/*
* For unimplemented "builtin" functions, try to invoke the
* non-builtin name
*/
static NODE *
binhelp(NODE *f, NODE *a, TWORD rt, char *n)
{
f->n_sp = lookup(addname(n), SNORMAL);
if (f->n_sp->sclass == SNULL) {
f->n_sp->sclass = EXTERN;
f->n_sp->stype = INCREF(rt)+(FTN-PTR);
}
f->n_type = f->n_sp->stype;
f = clocal(f);
return buildtree(CALL, f, a);
}
static NODE *
builtin_cir(const struct bitable *bt, NODE *a)
{
char *n;
if (a == NIL || a->n_op == CM) {
uerror("wrong argument count to %s", bt->name);
return bcon(0);
}
n = addname(bt->name[1] == 'r' ? "__real" : "__imag");
return cast(structref(a, DOT, n), bt->rt, 0);
}
static struct symtab *
addftn(char *n, TWORD t)
{
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
sp = lookup(addname(n), 0);
p->n_type = INCREF(t) + (FTN-PTR);
p->n_sp = sp;
p->n_df = memset(permalloc(sizeof(union dimfun)), 0,
sizeof(union dimfun));
defid(p, EXTERN);
nfree(p);
return sp;
}
void
myp2tree(NODE *p)
{
struct symtab *sp;
NODE *l, *r;
int o = p->n_op;
switch (o) {
case NAME: /* reading from a name must be done with a subroutine */
if (p->n_type != CHAR && p->n_type != UCHAR)
break;
l = buildtree(ADDROF, ccopy(p), NIL);
r = block(NAME, NIL, NIL, INT, 0, 0);
r->n_sp = lookup(addname("__nova_rbyte"), SNORMAL);
if (r->n_sp->sclass == SNULL) {
r->n_sp->sclass = EXTERN;
r->n_sp->stype = INCREF(p->n_type)+(FTN-PTR);
}
r->n_type = r->n_sp->stype;
r = clocal(r);
r = optim(buildtree(CALL, r, l));
*p = *r;
nfree(r);
break;
case FCON:
sp = tmpalloc(sizeof(struct symtab));
sp->sclass = STATIC;
sp->sap = 0;
sp->slevel = 1; /* fake numeric label */
sp->soffset = getlab();
sp->sflags = 0;
sp->stype = p->n_type;
sp->squal = (CON >> TSHIFT);
defloc(sp);
ninval(0, tsize(sp->stype, sp->sdf, sp->sap), p);
p->n_op = NAME;
p->n_lval = 0;
p->n_sp = sp;
}
}
/* construct a name object from a string
searches and if necessary installs string
in ternary search tree,
adding string to stack if so.
returns a generic object with
nametype tag with FBANK flag,
mark_.pad0 set to zero
mark_.padw contains XPOST_MEMORY_TABLE_SPECIAL_NAME_STACK stack index
*/
Xpost_Object xpost_name_cons(Xpost_Context *ctx,
const char *s)
{
unsigned int u;
unsigned int t;
Xpost_Object o;
unsigned int tstk;
int ret;
xpost_memory_table_get_addr(ctx->lo,
XPOST_MEMORY_TABLE_SPECIAL_NAME_TREE, &tstk);
u = tstsearch(ctx->lo, tstk, s);
if (!u) {
xpost_memory_table_get_addr(ctx->gl,
XPOST_MEMORY_TABLE_SPECIAL_NAME_TREE, &tstk);
u = tstsearch(ctx->gl, tstk, s);
if (!u) {
Xpost_Memory_File *mem = ctx->vmmode==GLOBAL?ctx->gl:ctx->lo;
Xpost_Memory_Table *tab = &mem->table;
ret = tstinsert(mem, tab->tab[XPOST_MEMORY_TABLE_SPECIAL_NAME_TREE].adr, s, &t);
if (ret)
{
//this can only be a VMerror
return invalid;
}
tab = &mem->table; //recalc pointer
tab->tab[XPOST_MEMORY_TABLE_SPECIAL_NAME_TREE].adr = t;
u = addname(ctx, s); // obeys vmmode
o.mark_.tag = nametype | (ctx->vmmode==GLOBAL?XPOST_OBJECT_TAG_DATA_FLAG_BANK:0);
o.mark_.pad0 = 0;
o.mark_.padw = u;
} else {
o.mark_.tag = nametype | XPOST_OBJECT_TAG_DATA_FLAG_BANK; // global
o.mark_.pad0 = 0;
o.mark_.padw = u;
}
} else {
o.mark_.tag = nametype; // local
o.mark_.pad0 = 0;
o.mark_.padw = u;
}
return o;
}
static char *
tistack(void)
{
struct symtab *sp, *sp2;
char buf[12];
NODE *q;
char *n;
/* allocate space on stack */
snprintf(buf, 12, "%d", getlab());
n = addname(buf);
sp = lookup(n, 0);
sp2 = tisp;
q = block(TYPE, NIL, NIL, sp2->stype, sp2->sdf, sp2->sap);
q->n_sp = sp;
nidcl2(q, AUTO, 0);
nfree(q);
return n;
}
/*
* For unimplemented "builtin" functions, try to invoke the
* non-builtin name
*/
static NODE *
binhelp(NODE *a, TWORD rt, char *n)
{
NODE *f = block(NAME, NIL, NIL, INT, 0, 0);
int oblvl = blevel;
blevel = 0;
f->n_sp = lookup(addname(n), SNORMAL);
blevel = oblvl;
if (f->n_sp->sclass == SNULL) {
f->n_sp->sclass = EXTERN;
f->n_sp->stype = INCREF(rt)+(FTN-PTR);
f->n_sp->sdf = permalloc(sizeof(union dimfun));
f->n_sp->sdf->dfun = NULL;
}
f->n_type = f->n_sp->stype;
f = clocal(f);
return buildtree(CALL, f, a);
}
/*
* Put all builtin functions into the global symbol table.
*/
void
builtin_init()
{
const struct bitable *bt;
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
int i;
for (i = 0; i < (int)(sizeof(bitable)/sizeof(bitable[0])); i++) {
bt = &bitable[i];
sp = lookup(addname(bt->name), 0);
if (bt->rt == 0 && (bt->flags & BTNORVAL) == 0)
cerror("function '%s' has no return type", bt->name);
p->n_type = INCREF(bt->rt) + (FTN-PTR);
p->n_sp = sp;
defid(p, EXTDEF);
sp->soffset = i;
sp->sflags |= SBUILTIN;
}
nfree(p);
}
void
gcc_init(void)
{
struct kw *kwp;
NODE *p;
TWORD t;
int i, d_debug;
d_debug = ddebug;
ddebug = 0;
for (kwp = kw; kwp->name; kwp++)
kwp->ptr = addname(kwp->name);
for (i = 0; i < 4; i++) {
struct symtab *sp;
t = ctype(g77t[i]);
p = block(NAME, NIL, NIL, t, NULL, 0);
sp = lookup(addname(g77n[i]), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
ddebug = d_debug;
#ifdef TARGET_TIMODE
{
struct attr *ap;
loti = addname("__loti");
hiti = addname("__hiti");
TISTR = addname("TI");
tisp = addstr("0ti");
cmpti2sp = addftn("__cmpti2", INT);
ucmpti2sp = addftn("__ucmpti2", INT);
addvti3sp = addftn("__addvti3", STRTY);
addvti3sp->sap = tisp->sap;
subvti3sp = addftn("__subvti3", STRTY);
subvti3sp->sap = tisp->sap;
mulvti3sp = addftn("__mulvti3", STRTY);
mulvti3sp->sap = tisp->sap;
divti3sp = addftn("__divti3", STRTY);
divti3sp->sap = tisp->sap;
modti3sp = addftn("__modti3", STRTY);
modti3sp->sap = tisp->sap;
ap = attr_new(GCC_ATYP_MODE, 3);
ap->sarg(0) = TISTR;
ap->iarg(1) = 1;
ap = attr_add(tisp->sap, ap);
udivti3sp = addftn("__udivti3", STRTY);
udivti3sp->sap = ap;
umodti3sp = addftn("__umodti3", STRTY);
umodti3sp->sap = ap;
ashldi3sp = addftn("__ashldi3", ctype(LONGLONG));
ashldi3sp->sap = ap;
ashrdi3sp = addftn("__ashrdi3", ctype(LONGLONG));
ashrdi3sp->sap = ap;
lshrdi3sp = addftn("__lshrdi3", ctype(LONGLONG));
lshrdi3sp->sap = ap;
floatuntixfsp = addftn("__floatuntixf", LDOUBLE);
}
#endif
}
/*
* Fixup types when modes given in defid().
*/
void
gcc_modefix(NODE *p)
{
struct attr *ap;
#ifdef TARGET_TIMODE
struct attr *a2;
#endif
struct symtab *sp;
char *s;
int i, u;
if ((ap = attr_find(p->n_ap, GCC_ATYP_MODE)) == NULL)
return;
u = ISUNSIGNED(BTYPE(p->n_type));
if ((i = amatch(ap->aa[0].sarg, mods, ATSZ)) == 0) {
werror("unknown mode arg %s", ap->aa[0].sarg);
return;
}
i = mods[i].typ;
if (i >= 1 && i <= MAXTYPES) {
MODTYPE(p->n_type, ctype(i));
if (u)
p->n_type = ENUNSIGN(p->n_type);
} else switch (i) {
#ifdef TARGET_TIMODE
case 800:
if (BTYPE(p->n_type) == STRTY)
break;
MODTYPE(p->n_type, tisp->stype);
p->n_df = tisp->sdf;
p->n_ap = tisp->sap;
if (ap->iarg(1) == u)
break;
/* must add a new mode struct to avoid overwriting */
a2 = attr_new(GCC_ATYP_MODE, 3);
a2->sarg(0) = ap->sarg(0);
a2->iarg(1) = u;
p->n_ap = attr_add(p->n_ap, a2);
break;
#endif
case FCOMPLEX:
case COMPLEX:
case LCOMPLEX:
/* Destination should have been converted to a struct already */
if (BTYPE(p->n_type) != STRTY)
uerror("gcc_modefix: complex not STRTY");
i -= (FCOMPLEX-FLOAT);
ap = strattr(p->n_ap);
sp = ap->amlist;
if (sp->stype == (unsigned)i)
return; /* Already correct type */
/* we must change to another struct */
s = i == FLOAT ? "0f" :
i == DOUBLE ? "0d" :
i == LDOUBLE ? "0l" : 0;
sp = lookup(addname(s), 0);
for (ap = sp->sap; ap != NULL; ap = ap->next)
p->n_ap = attr_add(p->n_ap, attr_dup(ap));
break;
default:
cerror("gcc_modefix");
}
}
/* control multiple files */
int
main(int argc, char *argv[])
{
int ch;
#ifdef TIMING
struct timeval t1, t2;
(void)gettimeofday(&t1, NULL);
#endif
prgname = argv[0];
while ((ch = getopt(argc, argv, "OT:VW:X:Z:f:gkm:psvwx:")) != -1) {
switch (ch) {
#if !defined(MULTIPASS) || defined(PASS1)
case 'X': /* pass1 debugging */
while (*optarg)
switch (*optarg++) {
case 'b': ++bdebug; break; /* buildtree */
case 'd': ++ddebug; break; /* declarations */
case 'e': ++edebug; break; /* pass1 exit */
case 'i': ++idebug; break; /* initializations */
case 'n': ++ndebug; break; /* node allocation */
case 'o': ++odebug; break; /* optim */
case 'p': ++pdebug; break; /* prototype */
case 's': ++sdebug; break; /* inline */
case 't': ++tdebug; break; /* type match */
case 'x': ++xdebug; break; /* MD code */
default:
fprintf(stderr, "unknown -X flag '%c'\n",
optarg[-1]);
exit(1);
}
break;
#endif
#if !defined(MULTIPASS) || defined(PASS2)
case 'Z': /* pass2 debugging */
while (*optarg)
switch (*optarg++) {
case 'b': /* basic block and SSA building */
++b2debug;
break;
case 'c': /* code printout */
++c2debug;
break;
case 'e': /* print tree upon pass2 enter */
++e2debug;
break;
case 'f': /* instruction matching */
++f2debug;
break;
case 'g': /* print flow graphs */
++g2debug;
break;
case 'n': /* node allocation */
++ndebug;
break;
case 'o': /* instruction generator */
++o2debug;
break;
case 'r': /* register alloc/graph coloring */
++r2debug;
break;
case 's': /* shape matching */
++s2debug;
break;
case 't': /* type matching */
++t2debug;
break;
case 'u': /* Sethi-Ullman debugging */
++u2debug;
break;
case 'x': /* target specific */
++x2debug;
break;
default:
fprintf(stderr, "unknown -Z flag '%c'\n",
optarg[-1]);
exit(1);
}
break;
#endif
case 'f': /* Language */
fflags(optarg);
break;
case 'g': /* Debugging */
++gflag;
break;
case 'k': /* PIC code */
++kflag;
break;
case 'm': /* Target-specific */
mflags(optarg);
break;
case 'p': /* Profiling */
++pflag;
break;
case 's': /* Statistics */
++sflag;
break;
case 'W': /* Enable different warnings */
Wflags(optarg);
break;
case 'x': /* Different settings */
xopt(optarg);
break;
case 'v':
printf("ccom: %s\n", VERSSTR);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0 && strcmp(argv[0], "-") != 0) {
if (freopen(argv[0], "r", stdin) == NULL) {
fprintf(stderr, "open input file '%s':",
argv[0]);
perror(NULL);
exit(1);
}
}
if (argc > 1 && strcmp(argv[1], "-") != 0) {
if (freopen(argv[1], "w", stdout) == NULL) {
fprintf(stderr, "open output file '%s':",
argv[1]);
perror(NULL);
exit(1);
}
}
mkdope();
signal(SIGSEGV, segvcatch);
#ifdef SIGBUS
signal(SIGBUS, segvcatch);
#endif
fregs = FREGS; /* number of free registers */
lineno = 1;
#ifdef GCC_COMPAT
gcc_init();
#endif
/* starts past any of the above */
reached = 1;
bjobcode();
#ifndef TARGET_VALIST
{
NODE *p = block(NAME, NIL, NIL, PTR|CHAR, NULL, 0);
struct symtab *sp = lookup(addname("__builtin_va_list"), 0);
p->n_sp = sp;
defid(p, TYPEDEF);
nfree(p);
}
#endif
complinit();
#ifdef STABS
if (gflag) {
stabs_file(argc ? argv[0] : "");
stabs_init();
}
#endif
if (sspflag)
sspinit();
(void) yyparse();
yyaccpt();
if (!nerrors)
lcommprint();
#ifdef STABS
if (gflag)
stabs_efile(argc ? argv[0] : "");
#endif
ejobcode( nerrors ? 1 : 0 );
#ifdef TIMING
(void)gettimeofday(&t2, NULL);
t2.tv_sec -= t1.tv_sec;
t2.tv_usec -= t1.tv_usec;
if (t2.tv_usec < 0) {
t2.tv_usec += 1000000;
t2.tv_sec -= 1;
}
fprintf(stderr, "ccom total time: %ld s %ld us\n",
t2.tv_sec, t2.tv_usec);
#endif
if (sflag)
prtstats();
return(nerrors?1:0);
}
/* -------------------------------------------------------------------------- */
int adddata ( void )
{
SINT check = 0;
SINT writing_position = -1;
SINT index = 0;
struct BOOK data;
struct STATUS sta;
memset( &sta, 0, sizeof( sta ));
memset( &data, 0, sizeof( data ));
check = statusread( &sta );
if( check == ERR ) {
return ERR;
}
for( index = 0 ; index < 10 ; index++ ) {
if( sta.flg[index] == 0 ) {
writing_position = index;
break;
}
}
if( writing_position == -1 ) {
printf( "これ以上追加できません。\n" );
return 0;
}
check = statusread( &sta );
if( check == ERR ) {
return ERR;
}
check = addname( &data );
if( check == ERR ) {
return ERR;
}
check = addkana( &data );
if( check == ERR ) {
return ERR;
}
check = addpost( &data );
if( check == ERR ) {
return ERR;
}
check = addaddress( &data );
if( check == ERR ) {
return ERR;
}
check = addnumber( &data );
if( check == ERR ) {
return ERR;
}
check = bookwrite( &data, writing_position );
if( check == ERR ) {
return ERR;
}
sta.flg[writing_position] = 1;
check = statuswrite( &sta );
if( check == ERR ) {
return ERR;
}
printf( "%d番目に追加しました\n", writing_position );
return 0;
}
void
collect_and_sort_names (void)
{
struct name *name;
struct name *next_name, *prev_name;
int num_names;
struct stat statbuf;
Hash_table *nametab;
name_gather ();
if (!namelist)
addname (".", 0, false, NULL);
if (listed_incremental_option)
{
switch (chdir_count ())
{
case 0:
break;
case 1:
if (namelist->change_dir == 0)
USAGE_ERROR ((0, 0,
_("Using -C option inside file list is not "
"allowed with --listed-incremental")));
break;
default:
USAGE_ERROR ((0, 0,
_("Only one -C option is allowed with "
"--listed-incremental")));
}
read_directory_file ();
}
num_names = 0;
for (name = namelist; name; name = name->next, num_names++)
{
if (name->found_count || name->directory)
continue;
if (name->matching_flags & EXCLUDE_WILDCARDS)
/* NOTE: EXCLUDE_ANCHORED is not relevant here */
/* FIXME: just skip regexps for now */
continue;
chdir_do (name->change_dir);
if (name->name[0] == 0)
continue;
if (deref_stat (dereference_option, name->name, &statbuf) != 0)
{
stat_diag (name->name);
continue;
}
if (S_ISDIR (statbuf.st_mode))
{
name->found_count++;
add_hierarchy_to_namelist (name, statbuf.st_dev, true);
}
}
namelist = merge_sort (namelist, num_names, compare_names);
num_names = 0;
nametab = hash_initialize (0, 0,
name_hash,
name_compare, NULL);
for (name = namelist; name; name = next_name)
{
next_name = name->next;
name->caname = normalize_filename (name->name);
if (prev_name)
{
struct name *p = hash_lookup (nametab, name);
if (p)
{
/* Keep the one listed in the command line */
if (!name->parent)
{
if (p->child)
rebase_child_list (p->child, name);
/* FIXME: remove_directory (p->caname); ? */
remname (p);
free_name (p);
num_names--;
}
else
{
if (name->child)
rebase_child_list (name->child, p);
/* FIXME: remove_directory (name->caname); ? */
remname (name);
free_name (name);
continue;
}
}
}
name->found_count = 0;
if (!hash_insert (nametab, name))
xalloc_die ();
prev_name = name;
num_names++;
}
nametail = prev_name;
hash_free (nametab);
namelist = merge_sort (namelist, num_names, compare_names_found);
if (listed_incremental_option)
{
for (name = namelist; name && name->name[0] == 0; name++)
;
if (name)
append_incremental_renames (name->directory);
}
}
static void
add_hierarchy_to_namelist (struct name *name, dev_t device, bool cmdline)
{
const char *buffer;
name_fill_directory (name, device, cmdline);
buffer = directory_contents (name->directory);
if (buffer)
{
struct name *child_head = NULL, *child_tail = NULL;
size_t name_length = name->length;
size_t allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
char *namebuf = xmalloc (allocated_length + 1);
/* FIXME: + 2 above? */
const char *string;
size_t string_length;
int change_dir = name->change_dir;
strcpy (namebuf, name->name);
if (! ISSLASH (namebuf[name_length - 1]))
{
namebuf[name_length++] = '/';
namebuf[name_length] = '\0';
}
for (string = buffer; *string; string += string_length + 1)
{
string_length = strlen (string);
if (*string == 'D')
{
struct name *np;
if (allocated_length <= name_length + string_length)
{
do
{
allocated_length *= 2;
if (! allocated_length)
xalloc_die ();
}
while (allocated_length <= name_length + string_length);
namebuf = xrealloc (namebuf, allocated_length + 1);
}
strcpy (namebuf + name_length, string + 1);
np = addname (namebuf, change_dir, false, name);
if (!child_head)
child_head = np;
else
child_tail->sibling = np;
child_tail = np;
add_hierarchy_to_namelist (np, device, false);
}
}
free (namebuf);
name->child = child_head;
}
}
void
collect_and_sort_names (void)
{
struct name *name;
struct name *next_name;
int num_names;
struct stat statbuf;
name_gather ();
if (listed_incremental_option)
read_directory_file ();
if (!namelist)
addname (".");
for (name = namelist; name; name = next_name)
{
next_name = name->next;
if (name->found || name->dir_contents)
continue;
if (name->regexp) /* FIXME: just skip regexps for now */
continue;
if (name->change_dir)
if (chdir (name->change_dir) < 0)
{
ERROR ((0, errno, _("Cannot chdir to %s"), name->change_dir));
continue;
}
if (
#ifdef AIX
statx (name->name, &statbuf, STATSIZE, STX_HIDDEN | STX_LINK)
#else
lstat (name->name, &statbuf) < 0
#endif
)
{
ERROR ((0, errno, _("Cannot stat %s"), name->name));
continue;
}
if (S_ISDIR (statbuf.st_mode))
{
name->found = 1;
add_hierarchy_to_namelist (name->name, statbuf.st_dev);
}
}
num_names = 0;
for (name = namelist; name; name = name->next)
num_names++;
namelist = (struct name *)
merge_sort ((voidstar) namelist, num_names,
(char *) (&(namelist->next)) - (char *) namelist,
compare_names);
for (name = namelist; name; name = name->next)
name->found = 0;
if (listed_incremental_option)
write_dir_file ();
}
/* clocal() is called to do local transformations on
* an expression tree preparitory to its being
* written out in intermediate code.
*
* the major essential job is rewriting the
* automatic variables and arguments in terms of
* REG and OREG nodes
* conversion ops which are not necessary are also clobbered here
* in addition, any special features (such as rewriting
* exclusive or) are easily handled here as well
*/
NODE *
clocal(NODE *p)
{
register struct symtab *q;
register NODE *r, *l;
register int o;
TWORD t;
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
switch( o = p->n_op ){
case NAME:
if ((q = p->n_sp) == NULL)
return p; /* Nothing to care about */
switch (q->sclass) {
case PARAM:
case AUTO:
/* fake up a structure reference */
r = block(REG, NIL, NIL, PTR+STRTY, 0, 0);
slval(r, 0);
r->n_rval = FPREG;
p = stref(block(STREF, r, p, 0, 0, 0));
break;
case REGISTER:
p->n_op = REG;
slval(p, 0);
p->n_rval = q->soffset;
break;
case USTATIC:
case STATIC:
if (kflag == 0)
break;
if (blevel > 0 && !statinit)
p = picstatic(p);
break;
case EXTERN:
case EXTDEF:
if (kflag == 0)
break;
if (blevel > 0 && !statinit)
p = picext(p);
break;
}
break;
case ADDROF:
if (kflag == 0 || blevel == 0 || statinit)
break;
/* char arrays may end up here */
l = p->n_left;
if (l->n_op != NAME ||
(l->n_type != ARY+CHAR && l->n_type != ARY+WCHAR_TYPE))
break;
l = p;
p = picstatic(p->n_left);
nfree(l);
if (p->n_op != UMUL)
cerror("ADDROF error");
l = p;
p = p->n_left;
nfree(l);
break;
case STASG: /* convert struct assignment to call memcpy */
l = p->n_left;
if (l->n_op == NAME && ISFTN(l->n_sp->stype))
break; /* struct return, do nothing */
/* first construct arg list */
p->n_left = buildtree(ADDROF, p->n_left, 0);
r = bcon(tsize(STRTY, p->n_df, p->n_ap)/SZCHAR);
p->n_left = buildtree(CM, p->n_left, p->n_right);
p->n_right = r;
p->n_op = CM;
p->n_type = INT;
r = block(NAME, NIL, NIL, INT, 0, 0);
r->n_sp = lookup(addname("memcpy"), SNORMAL);
if (r->n_sp->sclass == SNULL) {
r->n_sp->sclass = EXTERN;
r->n_sp->stype = INCREF(VOID+PTR)+(FTN-PTR);
}
r->n_type = r->n_sp->stype;
p = buildtree(CALL, r, p);
break;
case SCONV:
l = p->n_left;
if (l->n_op == ICON && ISPTR(l->n_type)) {
/* Do immediate cast here */
/* Should be common code */
q = l->n_sp;
l->n_sp = NULL;
l->n_type = UNSIGNED;
if (concast(l, p->n_type) == 0)
cerror("clocal");
p = nfree(p);
p->n_sp = q;
}
break;
case FORCE:
/* put return value in return reg */
p->n_op = ASSIGN;
p->n_right = p->n_left;
p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
t = p->n_type;
if (ISITY(t))
t = t - (FIMAG-FLOAT);
p->n_left->n_rval = RETREG(t);
break;
}
#ifdef PCC_DEBUG
if (xdebug) {
printf("clocal end: %p\n", p);
fwalk(p, eprint, 0);
}
#endif
return(p);
}
