void
free_cell_data(CELL * cp)
{
switch (cp->type) {
case C_RE:
TRACE(("\t... C_RE\n"));
re_destroy(cp->ptr);
zfree(cp, sizeof(CELL));
break;
case C_REPL:
TRACE(("\t... C_REPL\n"));
repl_destroy(cp);
zfree(cp, sizeof(CELL));
break;
case C_REPLV:
TRACE(("\t... C_REPLV\n"));
repl_destroy(cp);
zfree(cp, sizeof(CELL));
break;
case C_MBSTRN:
case C_STRING:
case C_STRNUM:
if (cp >= (field + (nf < 1 ? 1 : nf)) || (cp < field)) {
cell_destroy(cp);
}
break;
}
}
void
field_leaks(void)
{
int n;
free_STRING(string(CONVFMT));
free_STRING(string(FS));
free_STRING(string(OFMT));
free_STRING(string(RS));
cell_destroy(&field[0]);
for (n = 1; n <= nf; ++n) {
cell_destroy(&field[n]);
}
switch (fs_shadow.type) {
case C_RE:
re_destroy(fs_shadow.ptr);
break;
case C_STRING:
case C_STRNUM:
case C_MBSTRN:
cell_destroy(&fs_shadow);
break;
default:
break;
}
switch (rs_shadow.type) {
case SEP_STR:
free_STRING(((STRING *) (&rs_shadow.ptr)));
break;
case SEP_RE:
re_destroy(rs_shadow.ptr);
break;
}
}
int main(int argc, char *argv[]) {
LinkedList *ll = NULL;
TreeSet *ts = NULL;
char *sp;
char pattern[4096];
RegExp *reg;
Iterator *it;
if (argc < 2) {
fprintf(stderr, "Usage: ./fileCrawler pattern [dir] ...\n");
return -1;
}
/*
* convert bash expression to regular expression and compile
*/
cvtPattern(pattern, argv[1]);
if ((reg = re_create()) == NULL) {
fprintf(stderr, "Error creating Regular Expression Instance\n");
return -1;
}
if (! re_compile(reg, pattern)) {
char eb[4096];
re_status(reg, eb, sizeof eb);
fprintf(stderr, "Compile error - pattern: `%s', error message: `%s'\n",
pattern, eb);
re_destroy(reg);
return -1;
}
/*
* create linked list and treeset
*/
if ((ll = ll_create()) == NULL) {
fprintf(stderr, "Unable to create linked list\n");
goto done;
}
if ((ts = ts_create(scmp)) == NULL) {
fprintf(stderr, "Unable to create tree set\n");
goto done;
}
/*
* populate linked list
*/
if (argc == 2) {
if (! processDirectory(".", ll, 1))
goto done;
} else {
int i;
for (i = 2; i < argc; i++) {
if (! processDirectory(argv[i], ll, 1))
goto done;
}
}
/*
* for each directory in the linked list, apply regular expression
*/
while (ll_removeFirst(ll, (void **)&sp)) {
int stat = applyRe(sp, reg, ts);
free(sp);
if (! stat)
break;
}
/*
* create iterator to traverse files matching pattern in sorted order
*/
if ((it = ts_it_create(ts)) == NULL) {
fprintf(stderr, "Unable to create iterator over tree set\n");
goto done;
}
while (it_hasNext(it)) {
char *s;
(void) it_next(it, (void **)&s);
printf("%s\n", s);
}
it_destroy(it);
/*
* cleanup after ourselves so there are no memory leaks
*/
done:
if (ll != NULL)
ll_destroy(ll, free);
if (ts != NULL)
ts_destroy(ts, free);
re_destroy(reg);
return 0;
}
void
free_codes(const char *tag, INST * base, size_t size)
{
INST *cdp;
INST *last = base + (size / sizeof(*last));
CELL *cp;
(void) tag;
TRACE(("free_codes(%s) base %p, size %lu\n", tag, base, size));
if (base != 0 && size != 0) {
for (cdp = base; cdp < last; ++cdp) {
TRACE(("code %03d:%s (%d %#x)\n",
(int) (cdp - base),
da_op_name(cdp),
cdp->op,
cdp->op));
switch ((MAWK_OPCODES) (cdp->op)) {
case AE_PUSHA:
case AE_PUSHI:
++cdp; /* skip pointer */
cp = (CELL *) (cdp->ptr);
if (cp != 0) {
TRACE(("\tparam %p type %d\n", cp, cp->type));
free_cell_data(cp);
} else {
TRACE(("\tparam %p type ??\n", cp));
}
break;
case _MATCH0:
case _MATCH1:
++cdp; /* skip pointer */
re_destroy(cdp->ptr);
break;
case LAE_PUSHA:
case LA_PUSHA:
case A_CAT:
++cdp; /* skip value */
TRACE(("\tparam %d\n", cdp->op));
break;
case A_PUSHA:
case L_PUSHA:
case L_PUSHI:
case _BUILTIN:
case _PRINT:
case _PUSHA:
case _PUSHI:
case _PUSHINT:
++cdp; /* skip value */
TRACE(("\tparam %p\n", cdp->ptr));
break;
case _PUSHD:
++cdp; /* skip value */
TRACE(("\tparam %p\n", cdp->ptr));
if (cdp->ptr != &double_one && cdp->ptr != &double_zero)
zfree(cdp->ptr, sizeof(double));
break;
case F_PUSHI:
++cdp; /* skip pointer */
cp = (CELL *) (cdp->ptr);
TRACE(("\tparam %p type %d\n", cp, cp->type));
++cdp; /* skip integer */
break;
case _PUSHS:
++cdp; /* skip value */
TRACE(("\tparam %p\n", cdp->ptr));
free_STRING((STRING *) (cdp->ptr));
break;
case _RANGE:
cdp += 4; /* PAT1 */
break;
case _CALL:
TRACE(("\tskipping %d\n", 1 + cdp[2].op));
cdp += 1 + cdp[2].op;
break;
case A_DEL:
case A_TEST:
case DEL_A:
case FE_PUSHA:
case FE_PUSHI:
case F_ADD_ASG:
case F_ASSIGN:
case F_DIV_ASG:
case F_MOD_ASG:
case F_MUL_ASG:
case F_POST_DEC:
case F_POST_INC:
case F_POW_ASG:
case F_PRE_DEC:
case F_PRE_INC:
case F_PUSHA:
case F_SUB_ASG:
case NF_PUSHI:
case OL_GL:
case OL_GL_NR:
case POP_AL:
case _ADD:
case _ADD_ASG:
case _ASSIGN:
case _CAT:
case _DIV:
case _DIV_ASG:
case _EQ:
case _EXIT0: /* this does free memory... */
case _EXIT:
case _GT:
case _GTE:
case _HALT:
case _JMAIN:
case _LT:
case _LTE:
case _MATCH2:
case _MOD:
case _MOD_ASG:
case _MUL:
case _MUL_ASG:
case _NEQ:
case _NEXT:
case _NEXTFILE:
case _NOT:
case _OMAIN:
case _POP:
case _POST_DEC:
case _POST_INC:
case _POW:
case _POW_ASG:
case _PRE_DEC:
case _PRE_INC:
case _RET0:
case _RET:
case _STOP:
case _SUB:
case _SUB_ASG:
case _TEST:
case _UMINUS:
case _UPLUS:
break;
case _JNZ:
case _JZ:
case _LJZ:
case _LJNZ:
case _JMP:
case _PUSHC:
case ALOOP:
case LAE_PUSHI:
case SET_ALOOP:
++cdp; /* cdp->op is literal param */
break;
}
}
zfree(base, size);
}
}
