scope.h,
langdep.h,
sizes.h,
+ token.h,
+ expr.h,
rd.h
} ;
#include "idf.h"
#include "symbol.h"
#include "tree.h"
+#include "langdep.h"
+#include "token.h"
extern char *Salloc();
extern t_lineno currline;
extern FILE *db_in;
int errorgiven;
-int extended_charset = 0;
+static int extended_charset = 0;
+static int in_expression = 0;
jmp_buf jmpbuf;
static int init_del();
static int skip_to_eol();
-static struct token {
- int tokno;
- long ival;
- char *str;
- double fval;
- struct idf *idf;
-} tok, aside;
+struct token tok, aside;
-#define TOK tok.tokno
-#define ASIDE aside.tokno
+#define prio(op) ((*(currlang->op_prio))(op))
}
%start Commands, commands;
{ p_tree whr = 0, cond = 0, exp = 0; }
:
TRACE
- [ ON expression(&exp) ]?
+ [ ON expression(&exp, 1) ]?
where(&whr)?
condition(&cond)? { *p = mknode(OP_TRACE, whr, cond, exp); }
;
print_command(p_tree *p;)
:
- PRINT expression(p) { *p = mknode(OP_PRINT, *p);
+ PRINT expression(p, 1){ *p = mknode(OP_PRINT, *p);
p = &((*p)->t_args[0]);
}
[ ',' { *p = mknode(OP_LINK, *p, (p_tree) 0);
p = &((*p)->t_args[1]);
}
- expression(p)
+ expression(p, 1)
]*
;
condition(p_tree *p;)
:
- IF expression(p)
+ IF expression(p, 1)
;
where(p_tree *p;)
position(p)
;
-expression(p_tree *p;)
+expression(p_tree *p; int level;)
+ { int currprio, currop; }
+: { in_expression++; }
+ factor(p)
+ [ %while ((currprio = prio(currop = (int) tok.ival)) > level)
+ [ BIN_OP | PREF_OR_BIN_OP ]
+ { *p = mknode(OP_BINOP, *p, (p_tree) 0);
+ (*p)->t_whichoper = currop;
+ }
+ expression(&((*p)->t_args[1]), currprio)
+ ]*
+ { in_expression--; }
+;
+
+factor(p_tree *p;)
:
- qualified_name(p)
+ '(' expression(p, 1) ')'
+|
+ INTEGER { *p = mknode(OP_INTEGER, tok.ival); }
+|
+ REAL { *p = mknode(OP_REAL, tok.fval); }
+|
+ STRING { *p = mknode(OP_STRING, tok.str); }
+|
+ designator(p)
+|
+ PREF_OP { *p = mknode(OP_UNOP, (p_tree) 0);
+ (*p)->t_whichoper = (int) tok.ival;
+ }
+ factor(&(*p)->t_args[0])
+;
+
+designator(p_tree *p;)
+:
+ qualified_name(p)
+ [
+ SEL_OP { *p = mknode(OP_BINOP, *p, (p_tree) 0);
+ (*p)->t_whichoper = (int) tok.ival;
+ }
+ name(&(*p)->t_args[1])
+ |
+ '[' { *p = mknode(OP_BINOP, *p, (p_tree) 0);
+ (*p)->t_whichoper = '[';
+ }
+ expression(&(*p)->t_args[1], 1)
+ ']'
+ |
+ POST_OP { *p = mknode(OP_UNOP, *p);
+ (*p)->t_whichoper = (int) tok.ival;
+ }
+ ]*
;
position(p_tree *p;)
if (c == EOF) return c;
switch(class(c)) {
case STSTR:
- TOK = get_string(c);
+ TOK = (*currlang->get_string)(c);
break;
case STIDF:
- TOK = get_name(c);
+ if (in_expression) TOK = (*currlang->get_name)(c);
+ else TOK = get_name(c);
break;
case STDOT:
c = getc(db_in);
}
/* Fall through */
case STNUM:
- TOK = get_number(c);
+ TOK = (*currlang->get_number)(c);
break;
case STNL:
- case STSIMP:
TOK = c;
break;
+ case STSIMP:
+ if (! in_expression) {
+ TOK = c;
+ break;
+ }
+ /* Fall through */
default:
- error("illegal character '\\0%o'", c);
- return LLlex();
+ TOK = (*currlang->get_token)(c);
+ break;
}
return TOK;
}
}
-int get_string(c)
+int
+get_string(c)
int c;
{
register int ch;
;
structure_type(register p_type tp;)
- { register struct fields *fldp; }
+ { register struct fields *fldp;
+ register p_symbol s;
+ }
:
integer_const(&(tp->ty_size)) /* size in bytes */
+ { open_scope((p_symbol) 0, 0); }
[ { fldp = get_field_space(tp); }
name(&(fldp->fld_name))
+ { s = NewSymbol(fldp->fld_name, CurrentScope, FIELD, currnam);
+ s->sy_field = fldp;
+ }
type(&(fldp->fld_type), (int *) 0) ','
integer_const(&(fldp->fld_pos)) ',' /* offset in bits */
integer_const(&(fldp->fld_bitsize)) ';' /* size in bits */
]*
- ';' { end_field(tp); }
+ ';' { end_field(tp);
+ close_scope();
+ }
;
enum_type(register p_type tp;)
#include "position.h"
#include "operator.h"
#include "tree.h"
+#include "expr.h"
int
eval_cond(p)
/* language dependant routines: */
int (*printstring)();
long (*arrayelsize)();
+ int (*op_prio)();
+ int (*get_string)();
+ int (*get_name)();
+ int (*get_number)();
+ int (*get_token)();
};
extern struct langdep *m2_dep, *currlang;
while (p = strindex(progname, '/')) {
progname = p + 1;
}
- if (argv[1][0] == '-') {
+ if (argv[1] && argv[1][0] == '-') {
switch(argv[1][1]) {
case 'd':
debug++;
#include <stdio.h>
+#include "class.h"
#include "langdep.h"
+#include "Lpars.h"
+#include "idf.h"
+#include "token.h"
+#include "expr.h"
-extern FILE *db_out;
+extern FILE *db_out, *db_in;
+
+extern int
+ get_string();
+
+extern double
+ atof();
static int
- print_string();
+ print_string(),
+ get_number(),
+ get_name(),
+ get_token(),
+ op_prio();
static long
array_elsize();
"}",
print_string,
- array_elsize
+ array_elsize,
+ op_prio,
+ get_string,
+ get_name,
+ get_number,
+ get_token
};
struct langdep *m2_dep = &m2;
if (! (size % int_size)) return size;
return ((size + int_size - 1) / int_size) * int_size;
}
+
+static int
+op_prio(op)
+ int op;
+{
+ /* ??? to be written ??? */
+ return 1;
+}
+
+static int
+get_number(ch)
+ register int ch;
+{
+ /* The problem arising with the "parsing" of a number
+ is that we don't know the base in advance so we
+ have to read the number with the help of a rather
+ complex finite automaton.
+ */
+ enum statetp {Oct,Hex,Dec,OctEndOrHex,End,Real};
+ register enum statetp state;
+ char buf[512+1];
+ register int base = 10;
+ register char *np = &buf[0];
+
+ *np++ = ch;
+ state = is_oct(ch) ? Oct : Dec;
+ ch = getc(db_in);
+ for (;;) {
+ switch(state) {
+ case Oct:
+ while (is_oct(ch)) {
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ }
+ if (ch == 'B' || ch == 'C') {
+ state = OctEndOrHex;
+ break;
+ }
+ /* Fall Through */
+ case Dec:
+ base = 10;
+ while (is_dig(ch)) {
+ if (np < &buf[512]) {
+ *np++ = ch;
+ }
+ ch = getc(db_in);
+ }
+ if (is_hex(ch)) state = Hex;
+ else if (ch == '.') state = Real;
+ else {
+ state = End;
+ if (ch == 'H') base = 16;
+ else ungetc(ch, db_in);
+ }
+ break;
+
+ case Hex:
+ while (is_hex(ch)) {
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ }
+ base = 16;
+ state = End;
+ if (ch != 'H') {
+ error("H expected after hex number");
+ ungetc(ch, db_in);
+ }
+ break;
+
+ case OctEndOrHex:
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ if (ch == 'H') {
+ base = 16;
+ state = End;
+ break;
+ }
+ if (is_hex(ch)) {
+ state = Hex;
+ break;
+ }
+ ungetc(ch, db_in);
+ ch = *--np;
+ *np++ = '\0';
+ /* Fall through */
+
+ case End:
+ *np = '\0';
+ if (np >= &buf[512]) {
+ tok.ival = 1;
+ error("constant too long");
+ }
+ else {
+ np = &buf[0];
+ while (*np == '0') np++;
+ tok.ival = 0;
+ while (*np) {
+ int c;
+
+ if (is_dig(*np)) {
+ c = *np++ - '0';
+ }
+ else {
+ c = *np++ - 'A' + 10;
+ }
+ tok.ival *= base;
+ tok.ival += c;
+ }
+ }
+ return INTEGER;
+ }
+ if (state == Real) break;
+ }
+
+ /* a real real constant */
+ if (np < &buf[512]) *np++ = '.';
+
+ while (is_dig(ch)) {
+ /* Fractional part
+ */
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ }
+
+ if (ch == 'E') {
+ /* Scale factor
+ */
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ if (ch == '+' || ch == '-') {
+ /* Signed scalefactor
+ */
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ }
+ if (is_dig(ch)) {
+ do {
+ if (np < &buf[512]) *np++ = ch;
+ ch = getc(db_in);
+ } while (is_dig(ch));
+ }
+ else {
+ error("bad scale factor");
+ }
+ }
+
+ *np++ = '\0';
+ ungetc(ch, db_in);
+
+ if (np >= &buf[512]) {
+ tok.fval = 0.0;
+ error("real constant too long");
+ }
+ else tok.fval = atof(buf);
+ return REAL;
+}
+
+static int
+get_name(c)
+ register int c;
+{
+ char buf[512+1];
+ register char *p = &buf[0];
+ register struct idf *id;
+
+ do {
+ if (p - buf < 512) *p++ = c;
+ c = getc(db_in);
+ } while (in_idf(c));
+ ungetc(c, db_in);
+ *p = 0;
+ /* now recognize AND, DIV, IN, MOD, NOT, OR */
+ switch(buf[0]) {
+ case 'A':
+ if (strcmp(buf, "AND") == 0) {
+ tok.ival = E_AND;
+ return BIN_OP;
+ }
+ break;
+ case 'D':
+ if (strcmp(buf, "DIV") == 0) {
+ tok.ival = E_DIV;
+ return BIN_OP;
+ }
+ break;
+ case 'I':
+ if (strcmp(buf, "IN") == 0) {
+ tok.ival = E_IN;
+ return BIN_OP;
+ }
+ break;
+ case 'M':
+ if (strcmp(buf, "MOD") == 0) {
+ tok.ival = E_MOD;
+ return BIN_OP;
+ }
+ break;
+ case 'N':
+ if (strcmp(buf, "NOT") == 0) {
+ tok.ival = E_NOT;
+ return PREF_OP;
+ }
+ break;
+ case 'O':
+ if (strcmp(buf, "OR") == 0) {
+ tok.ival = E_OR;
+ return BIN_OP;
+ }
+ break;
+ }
+ id = str2idf(buf, 1);
+ tok.idf = id;
+ tok.str = id->id_text;
+ return id->id_reserved ? id->id_reserved : NAME;
+}
+
+static int
+get_token(c)
+ register int c;
+{
+ switch(c) {
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ case '`':
+ case '{':
+ case '}':
+ case ':':
+ case ',':
+ return c;
+
+ case '.':
+ tok.ival = E_SELECT;
+ return SEL_OP;
+ case '+':
+ tok.ival = E_PLUS;
+ return PREF_OR_BIN_OP;
+ case '-':
+ tok.ival = E_MIN;
+ return PREF_OR_BIN_OP;
+ case '*':
+ tok.ival = E_MUL;
+ return BIN_OP;
+ case '/':
+ tok.ival = E_DIV;
+ return BIN_OP;
+ case '&':
+ tok.ival = E_AND;
+ return BIN_OP;
+ case '|':
+ tok.ival = E_OR;
+ return BIN_OP;
+ case '=':
+ tok.ival = E_EQUAL;
+ return BIN_OP;
+ case '#':
+ tok.ival = E_NOTEQUAL;
+ return BIN_OP;
+ case '<':
+ c = getc(db_in);
+ if (c == '>') {
+ tok.ival = E_NOTEQUAL;
+ return BIN_OP;
+ }
+ if (c == '=') {
+ tok.ival = E_LTEQUAL;
+ return BIN_OP;
+ }
+ ungetc(c, db_in);
+ tok.ival = E_LT;
+ return BIN_OP;
+ case '>':
+ c = getc(db_in);
+ if (c == '=') {
+ tok.ival = E_GTEQUAL;
+ return BIN_OP;
+ }
+ ungetc(c, db_in);
+ tok.ival = E_GT;
+ return BIN_OP;
+ case '^':
+ tok.ival = E_DEREF;
+ return POST_OP;
+ case '~':
+ tok.ival = E_NOT;
+ return PREF_OP;
+ default:
+ error("illegal character 0%o", c);
+ return LLlex();
+ }
+}
OP_INPUT 1 0
OP_OUTPUT 1 0
OP_INTEGER 0 0
+OP_REAL 0 0
+OP_STRING 0 0
OP_NAME 0 0
OP_AT 0 0
OP_IN 1 0
OP_DUMP 0 do_dump
OP_RESTORE 0 do_restore
OP_TRACE 3 do_trace
+OP_UNOP 1 0
+OP_BINOP 2 0
fprintf(db_out, currlang->addr_fmt, BUFTOA(p));
}
else {
- print_val(par->par_type, q, 1, 0, param_bytes);
+ print_val(par->par_type, size, q, 1, 0);
}
free(q);
}
- else print_val(par->par_type, p, 1, 0, param_bytes);
+ else print_val(par->par_type, par->par_type->ty_size, p, 1, 0);
if (i) fputs(", ", db_out);
p += param_size(par->par_type, par->par_kind);
par++;
free(param_bytes);
}
-print_val(tp, addr, compressed, indent, AB)
+print_val(tp, tp_sz, addr, compressed, indent)
p_type tp; /* type of value to be printed */
+ long tp_sz; /* size of object to be printed */
char *addr; /* address to get value from */
int compressed; /* for parameter lists */
int indent; /* indentation */
- char *AB; /* argument base for dynamic subranges */
{
- long sz;
register int i;
long elsize;
if (indent == 0) indent = 4;
switch(tp->ty_class) {
case T_SUBRANGE:
- print_val(tp->ty_base, addr, compressed, indent, AB);
+ print_val(tp->ty_base, tp->ty_size, addr, compressed, indent);
break;
case T_ARRAY:
if (tp->ty_elements == char_type ||
tp->ty_elements == uchar_type) {
- print_val(string_type, addr, compressed, indent, AB);
+ print_val(string_type, tp_sz, addr, compressed, indent);
break;
}
- if ((sz = tp->ty_size) == 0) sz = compute_size(tp, AB);
if (compressed) {
fprintf(db_out, currlang->open_array_display);
}
}
indent += 4;
elsize = (*currlang->arrayelsize)(tp->ty_elements->ty_size);
- for (i = sz/elsize; i; i--) {
- print_val(tp->ty_elements, addr, compressed, indent, AB);
+ for (i = tp_sz/elsize; i; i--) {
+ print_val(tp->ty_elements, tp->ty_elements->ty_size, addr, compressed, indent);
addr += elsize;
if (compressed && i > 1) {
fprintf(db_out, ", ...");
}
indent += 4;
for (i = tp->ty_nfields; i; i--, fld++) {
+ long sz = fld->fld_type->ty_size;
if (! compressed) fprintf(db_out, "%s = ", fld->fld_name);
- if (fld->fld_bitsize != fld->fld_type->ty_size << 3) {
+ if (fld->fld_bitsize != sz << 3) {
/* apparently a bit field */
/* ??? */
fprintf(db_out, "<bitfield, %d, %d>", fld->fld_bitsize, fld->fld_type->ty_size);
}
- else print_val(fld->fld_type, addr+(fld->fld_pos>>3), compressed, indent, AB);
+ else print_val(fld->fld_type, sz, addr+(fld->fld_pos>>3), compressed, indent);
if (compressed && i > 1) {
fprintf(db_out, ", ...");
break;
fprintf(db_out, "<union>");
break;
case T_ENUM:
- print_literal(tp, tp->ty_size == 1
+ print_literal(tp, tp_sz == 1
? (*addr & 0xFF)
- : tp->ty_size == 2
+ : tp_sz == 2
? (BUFTOS(addr) & 0xFFFF)
: (int) BUFTOL(addr));
break;
break;
}
case T_UNSIGNED:
- print_unsigned(tp, tp->ty_size == 1
+ print_unsigned(tp, tp_sz == 1
? (*addr & 0xFF)
- : tp->ty_size == 2
+ : tp_sz == 2
? (BUFTOS(addr) & 0xFFFF)
: BUFTOL(addr));
break;
case T_INTEGER:
- print_integer(tp, tp->ty_size == 1
+ print_integer(tp, tp_sz == 1
? *addr
- : tp->ty_size == 2
+ : tp_sz == 2
? BUFTOS(addr)
: BUFTOL(addr));
break;
p_symbol sym;
{
char *buf;
- char *AB;
+ long size;
- if (get_value(sym, &buf, &AB)) {
+ if (get_value(sym, &buf, &size)) {
fputs(" = ", db_out);
- print_val(sym->sy_type, buf, 0, 0, AB);
+ print_val(sym->sy_type, size, buf, 0, 0);
if (buf) free(buf);
- if (AB) free(AB);
fputs("\n", db_out);
return 1;
}
#define REGVAR 0x0080
#define LOCVAR 0x0100
#define VARPAR 0x0200
-/* #define SYMENTRY 0x0400 /* a non-dbx entry */
+#define FIELD 0x0400
#define FILESYM 0x0800 /* a filename */
#define FILELINK 0x1000 /* a filename without its suffix */
struct idf *sy_idf; /* reference back to its idf structure */
/* struct outname syv_onam; /* for non-dbx entries */
struct file *syv_file; /* for FILESYM */
struct symbol *syv_fllink; /* for FILELINK */
+ struct fields *syv_field;
} sy_v;
#define sy_const sy_v.syv_const
#define sy_name sy_v.syv_name
#define sy_onam sy_v.syv_onam
#define sy_file sy_v.syv_file
#define sy_filelink sy_v.syv_fllink
+#define sy_field sy_v.syv_field
} t_symbol, *p_symbol;
/* ALLOCDEF "symbol" 50 */
--- /dev/null
+/* $Header$ */
+
+/* token structure for lexical analyzer */
+
+struct token {
+ int tokno;
+ long ival;
+ char *str;
+ double fval;
+ struct idf *idf;
+};
+
+extern struct token tok, aside;
+
+#define TOK tok.tokno
+#define ASIDE aside.tokno
{INTEGER, "number"},
{REAL, "real"},
{CHAR, "char"},
+ {BIN_OP, "<operator>"},
+ {PREF_OR_BIN_OP, "<operator>"},
+ {PREF_OP, "<operator>"},
+ {POST_OP, "<operator>"},
+ {SEL_OP, "<operator>"},
{0, ""}
};
#endif
case OP_INTEGER:
p->t_ival = va_arg(ap, long);
break;
+ case OP_STRING:
+ p->t_sval = va_arg(ap, char *);
+ break;
+ case OP_REAL:
+ p->t_fval = va_arg(ap, double);
+ break;
case OP_AT:
p->t_lino = va_arg(ap, long);
p->t_filename = va_arg(ap, char *);
register int na, i;
if (! p) return;
- switch(p->t_oper) {
- case OP_NAME:
- case OP_INTEGER:
- case OP_AT:
- case OP_CONT:
- case OP_NEXT:
- case OP_STEP:
- case OP_REGS:
- case OP_DELETE:
- break;
- default:
- na = nargs(p->t_oper);
- assert(na <= MAXARGS);
- for (i = 0; i < na; i++) {
- freenode(p->t_args[i]);
- }
- break;
+ na = nargs(p->t_oper);
+ assert(na <= MAXARGS);
+ for (i = 0; i < na; i++) {
+ freenode(p->t_args[i]);
}
free_tree(p);
}
case OP_INTEGER:
fprintf(db_out, "%d", p->t_ival);
break;
+ case OP_STRING:
+ fprintf(db_out, "%s", p->t_sval);
+ break;
+ case OP_REAL:
+ fprintf(db_out, "%.14g", p->t_fval);
+ break;
}
if (top_level) fputs("\n", db_out);
}
break;
case OP_NAME:
case OP_SELECT:
- sym = identify(p, VAR|REGVAR|LOCVAR|VARPAR);
+ sym = identify(p, VAR|REGVAR|LOCVAR|VARPAR|CONST);
if (! sym) return;
print_node(p, 0);
if (! print_sym(sym)) {
#define MAXARGS 3
typedef struct tree {
- int t_oper; /* operator */
+ short t_oper; /* tree operator */
+ short t_whichoper; /* expression operator */
t_addr t_address; /* some operators use an address */
int t_itemno; /* item number in status list */
union {
long tt_ival;
+ char *tt_sval;
+ double tt_fval;
struct {
struct idf *tt_idf;
char *tt_str;
t_position tt_pos;
} t_xxxx;
#define t_ival t_xxxx.tt_ival
+#define t_sval t_xxxx.tt_sval
+#define t_fval t_xxxx.tt_fval
#define t_idf t_xxxx.tt_x.tt_idf
#define t_str t_xxxx.tt_x.tt_str
#define t_sc t_xxxx.tt_x.tt_scope
extern long pointer_size;
extern t_addr *get_EM_regs();
+extern char *memcpy();
/* Get the value of the symbol indicated by sym.
Return 0 on failure,
1 on success.
- On success, 'buf' contains the value, and 'AB' may contain the parameters
- of the procedure invocation containing sym.
- For both of these, storage is allocated by Malloc; this storage must
+ On success, 'buf' contains the value, and 'size' contains the size.
+ For 'buf', storage is allocated by Malloc; this storage must
be freed by caller (I don't like this any more than you do, but caller
does not know sizes).
*/
int
-get_value(sym, buf, AB)
+get_value(sym, buf, psize)
register p_symbol sym;
- char **buf, **AB;
+ char **buf;
+ long *psize;
{
p_type tp = sym->sy_type;
long size = tp->ty_size;
t_addr *EM_regs;
int i;
p_scope sc, symsc;
+ char *AB;
*buf = 0;
- *AB = 0;
switch(sym->sy_class) {
case VAR:
/* exists if child exists; nm_value contains addres */
retval = 1;
}
break;
-
+ case CONST:
+ *buf = Malloc((unsigned) tp->ty_size);
+ switch(tp->ty_class) {
+ case T_REAL:
+ if (tp->ty_size != sizeof(double)) {
+ *((float *) *buf) = sym->sy_const.co_rval;
+ }
+ else *((double *) *buf) = sym->sy_const.co_rval;
+ break;
+ case T_INTEGER:
+ case T_SUBRANGE:
+ case T_UNSIGNED:
+ case T_ENUM:
+ if (tp->ty_size == 1) {
+ *((char *) *buf) = sym->sy_const.co_ival;
+ }
+ else if (tp->ty_size == 2) {
+ *((short *) *buf) = sym->sy_const.co_ival;
+ }
+ else {
+ *((long *) *buf) = sym->sy_const.co_ival;
+ }
+ break;
+ case T_SET:
+ memcpy(*buf, sym->sy_const.co_setval, (int) tp->ty_size);
+ break;
+ case T_STRING:
+ memcpy(*buf, sym->sy_const.co_sval, (int) tp->ty_size);
+ break;
+ default:
+ fatal("strange constant");
+ }
+ retval = 1;
+ break;
case VARPAR:
case LOCVAR:
/* first find the stack frame in which it resides */
size = proctype->ty_nbparams;
if (has_static_link(sc)) size += pointer_size;
- *AB = Malloc((unsigned) size);
- if (! get_bytes(size, EM_regs[AB_OFF], *AB)) {
+ AB = Malloc((unsigned) size);
+ if (! get_bytes(size, EM_regs[AB_OFF], AB)) {
break;
}
if ((size = tp->ty_size) == 0) {
- size = compute_size(tp, *AB);
+ size = compute_size(tp, AB);
}
}
*buf = Malloc((unsigned) size);
+ *psize = size;
if (get_bytes(size,
- (t_addr) BUFTOA(*AB+sym->sy_name.nm_value),
+ (t_addr) BUFTOA(AB+sym->sy_name.nm_value),
*buf)) {
retval = 1;
}
+ free(AB);
break;
}
if (retval == 0) {
if (*buf) free(*buf);
- if (*AB) free(*AB);
*buf = 0;
- *AB = 0;
+ *psize = 0;
}
return retval;
public / ack.git / commitdiff