assert.h
atw.h
blocks.c
-cem.1
-cem.c
cemcom.1
ch7.c
ch7bin.c
#ifndef NOFLOAT
#define SZ_FLOAT (arith)4
#define SZ_DOUBLE (arith)8
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define SZ_POINTER (arith)4
/* target machine alignment requirements */
#ifndef NOFLOAT
#define AL_FLOAT SZ_WORD
#define AL_DOUBLE SZ_WORD
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define AL_POINTER SZ_WORD
#define AL_STRUCT 1
#define AL_UNION 1
else { /* read ahead and return the old one */
#ifdef LINT
lint_comment_ahead();
-#endif LINT
+#endif /* LINT */
dot = ahead;
/* the following test is performed due to the dual
task of LLlex(): it is also called for parsing the
PushBack();
ch = '\\';
}
-#endif NOPP
+#endif /* NOPP */
if (040 < ch && ch < 0177)
lexerror("garbage char %c", ch);
else
ptok->tk_fund = INT;
return ptok->tk_symb = INTEGER;
}
-#endif NOPP
+#endif /* NOPP */
ptok->tk_symb = (
idef->id_reserved ? idef->id_reserved
: idef->id_def && idef->id_def->df_sc == TYPEDEF ?
/* in the rest of the compiler, all floats
have to start with a digit.
*/
-#else NOFLOAT
+#else /* NOFLOAT */
return ptok->tk_symb = ch;
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
if (ch == '0') {
*np++ = ch;
}
#ifndef NOFLOAT
if (base == 16 || !(ch == '.' || ch == 'e' || ch == 'E'))
-#endif NOFLOAT
+#endif /* NOFLOAT */
{
PushBack();
ptok->tk_ival = val;
else
ptok->tk_fval = Salloc(buf,(unsigned) (np - buf)) + 1;
return ptok->tk_symb = FLOATING;
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
case STEOI: /* end of text on source file */
return ptok->tk_symb = EOI;
#ifdef LINT
lint_start_comment();
lint_comment_char(c);
-#endif LINT
+#endif /* LINT */
do {
while (c != '*') {
if (class(c) == STNL)
NoUnstack--;
#ifdef LINT
lint_end_comment();
-#endif LINT
+#endif /* LINT */
return;
}
LoadChar(c);
#ifdef LINT
lint_comment_char(c);
-#endif LINT
+#endif /* LINT */
} /* last Character seen was '*' */
LoadChar(c);
#ifdef LINT
lint_comment_char(c);
-#endif LINT
+#endif /* LINT */
} while (c != '/');
#ifdef LINT
lint_end_comment();
-#endif LINT
+#endif /* LINT */
NoUnstack--;
}
} tok_integer;
#ifndef NOFLOAT
char *tok_fval;
-#endif NOFLOAT
+#endif /* NOFLOAT */
} tok_data;
};
#define tk_ival tok_data.tok_integer.tok_ival
#ifndef NOFLOAT
#define tk_fval tok_data.tok_fval
-#endif NOFLOAT
+#endif /* NOFLOAT */
extern struct token dot, ahead, aside;
extern int token_nmb; /* number of the ahead token */
extern int AccDefined; /* "LLlex.c" */
extern int Unstacked; /* "LLlex.c" */
extern int UnknownIdIsZero; /* "LLlex.c" */
-#endif NOPP
+#endif /* NOPP */
extern int EoiForNewline; /* "LLlex.c" */
extern int AccFileSpecifier; /* "LLlex.c" */
extern int SkipEscNewline; /* "LLlex.c" */
case FLOATING:
dot.tk_fval = Salloc("0.0", 4);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
}
echo '#ifndef lint' > Version.c
echo 'char Version[] = "ACK C compiler Version XXX";' | \
sed "s/XXX/`RC -i`/" >> Version.c
- echo '#endif lint' >> Version.c
+ echo '#endif' >> Version.c
#ifndef NOFLOAT
#define SZ_FLOAT (arith)4
#define SZ_DOUBLE (arith)8
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define SZ_POINTER (arith)4
/* target machine alignment requirements */
#ifndef NOFLOAT
#define AL_FLOAT SZ_WORD
#define AL_DOUBLE SZ_WORD
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define AL_POINTER SZ_WORD
#define AL_STRUCT 1
#define AL_UNION 1
short_align, word_align, int_align, long_align,
#ifndef NOFLOAT
float_align, double_align,
-#endif NOFLOAT
+#endif /* NOFLOAT */
pointer_align,
struct_align, union_align;
-#else NOCROSS
+#else /* NOCROSS */
#define short_align ((int)AL_SHORT)
#define word_align ((int)AL_WORD)
#define int_align ((int)AL_INT)
#ifndef NOFLOAT
#define float_align ((int)AL_FLOAT)
#define double_align ((int)AL_DOUBLE)
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define pointer_align ((int)AL_POINTER)
#define struct_align ((int)AL_STRUCT)
#define union_align ((int)AL_UNION)
-#endif NOCROSS
+#endif /* NOCROSS */
extern arith align();
int2float(e1p, double_type);
return;
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
/* Now they are INT or LONG */
u1 = (*e1p)->ex_type->tp_unsigned;
}
else
expr_warning(*expp, "%s on enum", symbol2str(oper));
-#endif NOROPTION
+#endif /* NOROPTION */
#ifndef LINT
int2int(expp, int_type);
-#endif LINT
+#endif /* LINT */
break;
#ifndef NOFLOAT
case FLOAT:
break;
case DOUBLE:
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
#ifndef NOBITFIELD
case FIELD:
field2arith(expp);
break;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
default:
expr_error(*expp, "operator %s on non-numerical operand (%s)",
symbol2str(oper), symbol2str(fund));
else
*expp = arith2arith(tp, FLOAT2FLOAT, *expp);
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
array2pointer(exp)
register struct expr *exp;
else
if (fund == FIELD)
field2arith(expp);
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
switch (fund = (*expp)->ex_type->tp_fund) {
case CHAR:
case SHORT:
#ifndef NOFLOAT
case FLOAT:
case DOUBLE:
-#endif NOFLOAT
+#endif /* NOFLOAT */
break;
default:
expr_error(*expp, "%s operand to %s",
case ENUM:
#ifndef NOFLOAT
case FLOAT:
-#endif NOFLOAT
+#endif /* NOFLOAT */
any2arith(expp, oper);
break;
case ARRAY:
case FIELD:
field2arith(expp);
break;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
}
}
}
ch7cast(expp, CAST, tp); /* restore its original type */
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
#ifndef NOFLOAT
/* switch_sign_fp() negates the given floating constant expression
else
--(expr->FL_VALUE);
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
#include <em_arith.h> /* obtain definition of "arith" */
-#else SPECIAL_ARITHMETICS
+#else /* SPECIAL_ARITHMETICS */
/* not implemented yet */
#define arith int /* dummy */
-#endif SPECIAL_ARITHMETICS
+#endif /* SPECIAL_ARITHMETICS */
#else
#define ASSERT(exp)
#define NOTREACHED()
-#endif DEBUG
+#endif /* DEBUG */
#include "Lpars.h"
extern arith NewLocal();
#define LocalPtrVar() NewLocal(pointer_size, pointer_align, reg_pointer, REGISTER)
-#endif STB
+#endif /* STB */
/* Because EM does not support the loading and storing of
objects having other sizes than word fragment and multiple,
C_asp(ATW(sz));
FreeLocal(dst);
FreeLocal(src);
-#else STB
+#else /* STB *?
/* address of destination lies on the stack */
/* push address of first byte of block on stack onto
C_loc(sz); /* number of bytes to transfer */
C_cal("__stb"); /* call transfer routine */
C_asp(pointer_size + pointer_size + int_size + ATW(sz));
-#endif STB
+#endif /* STB */
}
}
copy_loop(sz, src, dst);
FreeLocal(dst);
FreeLocal(src);
-#else STB
+#else /* STB */
C_asp(-(esz - pointer_size)); /* allocate stack block */
C_lor((arith)1); /* push & of stack block as dst */
C_dup(pointer_size); /* fetch source address */
C_loc(sz); /* # bytes to copy */
C_cal("__stb"); /* library copy routine */
C_asp(int_size + pointer_size + pointer_size);
-#endif STB
+#endif /* STB */
}
}
C_df_ilb(l_stop);
C_asp(word_size);
}
-#endif STB
+#endif /* STB */
-#endif LINT
+#endif /* LINT */
ch7cast(expp, oper, tp->tp_up);
}
else
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
if (oldtp == tp) {
/* life is easy */
}
(*expp)->ex_type = tp;
else
int2int(expp, tp);
-#else LINT
+#else /* LINT */
int2int(expp, tp);
-#endif LINT
+#endif /* LINT */
}
#ifndef NOFLOAT
else
(*expp)->ex_type = tp;
else
int2float(expp, tp);
-#else LINT
+#else /* LINT */
int2float(expp, tp);
-#endif LINT
+#endif /* LINT */
}
else
if (!oldi && i) {
(*expp)->ex_type = tp;
else
float2int(expp, tp);
-#else LINT
+#else /* LINT */
float2int(expp, tp);
-#endif LINT
+#endif /* LINT */
}
else {
/* !oldi && !i */
(*expp)->ex_type = tp;
else
float2float(expp, tp);
-#else LINT
+#else /* LINT */
float2float(expp, tp);
-#endif LINT
+#endif /* LINT */
}
-#else NOFLOAT
+#else /* NOFLOAT */
else {
crash("(ch7cast) floats not implemented\n");
/*NOTREACHED*/
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
else
if (oldtp->tp_fund == POINTER && tp->tp_fund == POINTER) {
#ifdef LINT
if (oper != CAST)
lint_ptr_conv(oldtp->tp_up->tp_fund, tp->tp_up->tp_fund);
-#endif LINT
+#endif /* LINT */
(*expp)->ex_type = tp; /* free conversion */
}
else
exp = new_oper(exp->ex_type->tp_up, exp, oper, expr);
else
exp = new_oper(exp->ex_type, exp, oper, expr);
-#else NOBITFIELD
+#else /* NOBITFIELD */
exp = new_oper(exp->ex_type, exp, oper, expr);
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
exp->OP_TYPE = tp; /* for EVAL() */
exp->ex_flags |= EX_SIDEEFFECTS;
*expp = exp;
#ifndef NOBITFIELD
case FIELD:
return is_integral_type(tp->tp_up);
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
default:
return 0;
}
#ifndef NOFLOAT
case FLOAT:
case DOUBLE:
-#endif NOFLOAT
+#endif /* NOFLOAT */
return 1;
#ifndef NOBITFIELD
case FIELD:
return is_arith_type(tp->tp_up);
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
default:
return 0;
}
#ifndef NOROPTION
if (options['R'])
warning("function pointer called");
-#endif NOROPTION
+#endif /* NOROPTION */
ch7mon('*', expp);
}
switch ((*expp)->ex_type->tp_fund) {
) {
hwarning("operands of : are constant and equal");
}
-#endif LINT
+#endif /* LINT */
*expp = new_oper((*expp)->ex_type, *expp, oper, expr);
break;
if (is_cp_cst(*expp)) {
#ifdef LINT
hwarning("condition in ?: expression is constant");
-#endif LINT
+#endif /* LINT */
*expp = (*expp)->VL_VALUE ?
expr->OP_LEFT : expr->OP_RIGHT;
}
if (is_cp_cst(*expp)) {
#ifdef LINT
hwarning("constant expression ignored");
-#endif LINT
+#endif /* LINT */
*expp = expr;
}
else {
"illegal combination of float and pointer");
erroneous2int(expp2);
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
ch7bin( expp2, '*',
intexpr(size_of_type((*expp1)->ex_type->tp_up, "object"),
pa_type->tp_fund)
if ((*expp)->ex_type->tp_fund == FIELD)
expr_error(*expp, "& applied to field variable");
else
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
if (!(*expp)->ex_lvalue)
expr_error(*expp, "& applied to non-lvalue");
else {
}
/* FALLTHROUGH */
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
case '-':
any2arith(expp, oper);
if (is_cp_cst(*expp)) {
if (is_fp_cst(*expp))
switch_sign_fp(*expp);
else
-#endif NOFLOAT
+#endif /* NOFLOAT */
*expp = new_oper((*expp)->ex_type,
NILEXPR, oper, *expp);
break;
#else
#include "l_em.h"
#include "l_lint.h"
-#endif LINT
+#endif /* LINT */
#include "botch_free.h"
#include <alloc.h>
#include "dataflow.h"
#ifndef NOFLOAT
int fp_used;
-#endif NOFLOAT
+#endif /* NOFLOAT */
/* global function info */
char *func_name;
#ifdef USE_TMP
static int tmp_id;
static int pro_id;
-#endif USE_TMP
+#endif /* USE_TMP */
extern char options[];
extern char *symbol2str();
#ifdef USE_TMP
#ifdef PREPEND_SCOPES
C_insertpart(tmp_id = C_getid());
-#endif USE_TMP
-#endif PREPEND_SCOPES
+#endif /* USE_TMP */
+#endif /* PREPEND_SCOPES */
}
-#endif LINT
+#endif /* LINT */
struct string_cst *str_list = 0;
/* floating point used */
C_ms_flt();
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
def_strings(str_list);
str_list = 0;
C_ms_src((int)(LineNumber - 2), FileName);
C_close();
}
-#endif LINT
+#endif /* LINT */
#ifdef PREPEND_SCOPES
prepend_scopes()
#ifdef USE_TMP
C_beginpart(tmp_id);
-#endif USE_TMP
+#endif /* USE_TMP */
while (se != 0) {
register struct idf *id = se->se_idf;
register struct def *df = id->id_def;
}
#ifdef USE_TMP
C_endpart(tmp_id);
-#endif USE_TMP
+#endif /* USE_TMP */
}
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
code_scope(text, def)
char *text;
*/
#ifndef PREPEND_SCOPES
code_scope(name, def);
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
#ifdef DATAFLOW
if (options['d'])
DfaStartFunction(name);
-#endif DATAFLOW
+#endif /* DATAFLOW */
/* set global function info */
func_name = name;
#ifdef DATAFLOW
if (options['d'])
DfaEndFunction();
-#endif DATAFLOW
+#endif /* DATAFLOW */
C_df_ilb(return2_label);
if (return_expr_occurred) C_asp(-func_size);
C_df_ilb(return_label);
C_ret(func_size);
}
else C_ret((arith) 0);
-#endif LINT
+#endif /* LINT */
/* getting the number of "local" bytes is posponed until here,
because copying the function result in "func_res_label" may
if (expr) { /* code only if initialized */
#ifndef PREPEND_SCOPES
code_scope(idf->id_text, def);
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
def->df_alloc = ALLOC_DONE;
C_df_dnam(idf->id_text);
}
if (e->OP_RIGHT != 0) /* int i = {1 , 2} */
expr_error(e, "too many initializers");
}
-#endif NOROPTION
+#endif /* NOROPTION */
while (e) {
loc_init(e->OP_LEFT, id);
e = e->OP_RIGHT;
vl.vl_value = (arith)0;
store_val(&vl, tp);
}
-#else LINT
+#else /* LINT */
id->id_def->df_set = 1;
-#endif LINT
+#endif /* LINT */
free_expression(expr);
}
}
#ifndef PREPEND_SCOPES
code_scope(idf->id_text, idf->id_def);
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
#ifdef DBSYMTAB
if (options['g']) {
stb_string(idf->id_def, idf->id_def->df_sc, idf->id_text);
#ifdef LINT
/*ARGSUSED*/
-#endif LINT
+#endif /* LINT */
code_expr(expr, val, code, tlbl, flbl)
struct expr *expr;
label tlbl, flbl;
if (options['g']) db_line(expr->ex_file, (unsigned int)expr->ex_line);
#endif
EVAL(expr, val, code, tlbl, flbl);
-#else LINT
+#else /* LINT */
lint_expr(expr, code ? USED : IGNORED);
-#endif LINT
+#endif /* LINT */
}
/* The FOR/WHILE/DO/SWITCH stacking mechanism:
#define T_UNSIGNED 2
#ifndef NOFLOAT
#define T_FLOATING 3
-#endif NOFLOAT
+#endif /* NOFLOAT */
/* conversion() generates the EM code for a conversion between
the types char, short, int, long, float, double and pointer.
case T_UNSIGNED:
#ifndef NOFLOAT
case T_FLOATING:
-#endif NOFLOAT
+#endif /* NOFLOAT */
if ((int)from_size < (int)word_size) {
C_loc(from_size);
C_loc(word_size);
case T_FLOATING:
C_cuf();
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
break;
#ifndef NOFLOAT
break;
}
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("(conversion) illegal type conversion");
/*NOTREACHED*/
if ((int)(to_type->tp_size) < (int)word_size
#ifndef NOFLOAT
&& to_cnvtype != T_FLOATING
-#endif NOFLOAT
+#endif /* NOFLOAT */
) {
extern long full_mask[];
case FLOAT:
case DOUBLE:
return T_FLOATING;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case POINTER:
return T_UNSIGNED;
}
return 0;
}
-#endif LINT
+#endif /* LINT */
print("DFA: %s: %s\n", CurrentFunction, s);
++NumberOfCalls;
}
-#endif DATAFLOW
+#endif /* DATAFLOW */
#include "level.h"
#ifdef LINT
#include "l_lint.h"
-#endif LINT
+#endif /* LINT */
extern char options[];
}
declare_idf(ds, &Dc, level);
#ifdef LINT
lint_declare_idf(Dc.dc_idf, ds->ds_sc);
-#endif LINT
+#endif /* LINT */
}
[
initializer(Dc.dc_idf, ds->ds_sc)
{
#ifdef LINT
add_auto(Dc.dc_idf);
-#endif LINT
+#endif /* LINT */
remove_declarator(&Dc);
}
;
{
#ifdef LINT
lint_statement();
-#endif LINT
+#endif /* LINT */
if (globalflag) {
struct expr ex;
code_declaration(idf, &ex, level, sc);
}
#ifdef DEBUG
print_expr("initializer-expression", expr);
-#endif DEBUG
+#endif /* DEBUG */
#ifdef LINT
change_state(idf, SET);
-#endif LINT
+#endif /* LINT */
#ifdef DBSYMTAB
if (options['g'] && level >= L_LOCAL && expr) {
db_line(expr->ex_file, (unsigned) expr->ex_line)
free_expression(expr);
#ifdef NOBITFIELD
error("bitfields are not implemented");
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
}
;
if (tp == float_type)
tp = double_type;
else
-#endif NOFLOAT
+#endif /* NOFLOAT */
error("long with illegal type");
break;
}
char df_set;
int df_firstbrace; /* brace number of its first occurrence */
int df_minlevel; /* the lowest level needed for this def */
-#endif LINT
+#endif /* LINT */
char df_formal_array; /* to warn if sizeof is taken */
arith df_address;
};
return (*s == '\0') && (*t == '\0');
}
}
-#else NOPP
+#else /* NOPP */
EXPORT
domacro()
{
EoiForNewline = 0;
SkipEscNewline = 0;
}
-#endif NOPP
+#endif /* NOPP */
PRIVATE
SkipRestOfLine()
}
print(" macro");
}
-#endif NOPP
+#endif /* NOPP */
if ((opt&2) && idf->id_reserved) {
if (!started++) {
newline();
print("L%d: ", sdef->sd_level);
#ifndef NOBITFIELD
if (sdk == selector)
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
print("selector %s at offset %lu in %s;",
type2str(sdef->sd_type),
sdef->sd_offset, type2str(sdef->sd_stype)
else print("field %s at offset %lu;",
type2str(sdef->sd_type), sdef->sd_offset
);
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
sdef = (sdk == selector ? sdef->next : sdef->sd_sdef);
}
dumplevel--;
fd->fd_shift, fd->fd_width);
}
else
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
ops = 0;
break;
}
expr->ex_class == String ? "String" :
#ifndef NOFLOAT
expr->ex_class == Float ? "Float" :
-#endif NOFLOAT
+#endif /* NOFLOAT */
expr->ex_class == Oper ? "Oper" :
expr->ex_class == Type ? "Type" : "UNKNOWN CLASS"
);
case Float:
print("%s\n", expr->FL_VALUE);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case Oper:
o = &expr->ex_object.ex_oper;
print("\n");
while (lvl--)
print(" ");
}
-#endif DEBUG
+#endif /* DEBUG */
#include <em.h>
#else
#include "l_em.h"
-#endif LINT
+#endif /* LINT */
#include "nopp.h"
#include "errout.h"
extern char options[];
#ifdef LINT
extern char loptions[];
-#endif LINT
+#endif /* LINT */
/* There are three general error-message functions:
lexerror() lexical and pre-processor error messages
va_end(ap);
}
-#endif LINT
+#endif /* LINT */
/*VARARGS*/
lexerror(va_alist) /* fmt, args */
}
va_end(ap);
}
-#endif NOPP
+#endif /* NOPP */
/*VARARGS*/
crash(va_alist) /* fmt, args */
C_close();
#ifdef DEBUG
sys_stop(S_ABORT);
-#else DEBUG
+#else /* DEBUG */
sys_stop(S_EXIT);
-#endif DEBUG
+#endif /* DEBUG */
/* NOTREACHED */
}
case WARNING:
#ifndef LINT
remark = "(warning)";
-#else LINT
+#else /* LINT */
remark = 0;
-#endif LINT
+#endif /* LINT */
break;
case ERROR:
/* we skip this message */
return;
}
-#endif LINT
+#endif /* LINT */
if (fn)
fprint(ERROUT, "\"%s\", line %u: ", fn, ln);
C_loi(expr->ex_type->tp_size);
}
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case Oper: /* compound expression */
{
int oper = expr->OP_OPER;
case DOUBLE:
C_adf(tp->tp_size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("bad type +");
}
case DOUBLE:
C_ngf(tp->tp_size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
CRASH();
}
case DOUBLE:
C_sbf(tp->tp_size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("bad type -");
}
case DOUBLE:
C_mlf(double_size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("bad type *");
}
case DOUBLE:
C_dvf(double_size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("bad type /");
}
case DOUBLE:
C_cmf(size);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case POINTER:
C_cmp();
break;
eval_field(expr, gencode);
break;
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
EVAL(right, RVAL, newcode, NO_LABEL, NO_LABEL);
if (gencode)
C_dup(ATW(tp->tp_size));
eval_field(expr, gencode);
break;
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
if (newcode && left->ex_class == Value) {
compl = 0; /* Value */
}
DfaCallFunction(
left->VL_IDF->id_text);
}
-#endif DATAFLOW
+#endif /* DATAFLOW */
}
else {
EVAL(left, LVAL, TRUE, NO_LABEL, NO_LABEL);
case INT2FLOAT:
case FLOAT2INT:
case FLOAT2FLOAT:
-#endif NOFLOAT
+#endif /* NOFLOAT */
EVAL(right, RVAL, gencode, NO_LABEL, NO_LABEL);
if (gencode)
conversion(right->ex_type, left->ex_type);
break;
}
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case POINTER:
if (oper == MINAB || oper == MINMIN || oper == POSTDECR)
C_ngi(size);
}
}
-#endif LINT
+#endif /* LINT */
case FLOATING:
float2expr(ex);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
default:
crash("bad conversion to expression");
/*NOTREACHED*/
def->df_used = 1;
#ifndef PREPEND_SCOPES
code_scope(idf->id_text, def);
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
}
-#endif LINT
+#endif /* LINT */
expr->ex_type = def->df_type;
if (expr->ex_type == error_type)
expr->ex_flags |= EX_ERROR;
expr->VL_LBL = def->df_address;
expr->VL_VALUE = (arith)0;
}
-#endif LINT
+#endif /* LINT */
else {
expr->VL_CLASS = Name;
expr->VL_IDF = idf;
expr->FL_VALUE = dot.tk_fval;
expr->FL_DATLAB = 0;
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
struct expr*
intexpr(ivalue, fund)
op->op_right = e2;
#ifdef LINT
lint_new_oper(expr);
-#endif LINT
+#endif /* LINT */
return expr;
}
#ifdef DEBUG
print_expr("constant_expression", expr);
-#endif DEBUG
+#endif /* DEBUG */
if ( fund != CHAR && fund != SHORT && fund != INT &&
fund != ENUM && fund != LONG
)
expr_warning(expr,
"expression comma in constant expression");
}
-#endif NOROPTION
+#endif /* NOROPTION */
if (err)
erroneous2int(expp);
}
#ifdef LINT
if (expr->ex_class == String)
return 1;
-#endif LINT
+#endif /* LINT */
return expr->ex_lvalue == 0 && expr->ex_class == Value;
}
*/
return expr->ex_class == Float;
}
-#endif NOFLOAT
+#endif /* NOFLOAT */
free_expression(expr)
register struct expr *expr;
char *fl_value; /* pointer to string repr. the fp const. */
label fl_datlab; /* global data_label */
};
-#endif NOFLOAT
+#endif /* NOFLOAT */
struct oper {
struct type *op_type; /* resulting type of the operation */
#define String 1 /* it is a string constant */
#ifndef NOFLOAT
#define Float 2 /* it is a floating point constant */
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define Oper 3 /* it is a run-time expression */
#define Type 4 /* only its type is relevant */
struct string ex_string;
#ifndef NOFLOAT
struct floating ex_float;
-#endif NOFLOAT
+#endif /* NOFLOAT */
struct oper ex_oper;
} ex_object;
};
#ifndef NOFLOAT
#define FL_VALUE ex_object.ex_float.fl_value
#define FL_DATLAB ex_object.ex_float.fl_datlab
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define OP_TYPE ex_object.ex_oper.op_type
#define OP_LEFT ex_object.ex_oper.op_left
#define OP_OPER ex_object.ex_oper.op_oper
conversion(atype, expr->ex_type);
}
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
-#endif LINT
+#endif /* LINT */
notch->id_text = Salloc(tg, (unsigned) size);
#ifndef NOPP
notch->id_resmac = 0;
-#endif NOPP
+#endif /* NOPP */
return notch;
}
print("End hash table tally\n");
}
}
-#endif DEBUG
+#endif /* DEBUG */
struct idf *
str2idf(tg)
case FLOAT: /* RM 10.1 */
type = double_type;
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case CHAR:
case SHORT:
/* The RM is not clear about this: we must
#ifdef LINT
check_hiding(idf, lvl, sc); /* of some idf by this idf */
-#endif LINT
+#endif /* LINT */
if (def &&
( def->df_level == lvl ||
#ifdef LINT
newdef->df_set = 0;
newdef->df_firstbrace = 0;
-#endif LINT
+#endif /* LINT */
/* link it into the name list in the proper place */
idf->id_def = newdef;
/* warn unconditionally */
warning("%s redeclared to static",
idf->id_text);
-#else LINT
+#else /* LINT */
#ifndef NOROPTION
/* warn conditionally */
if (options['R'])
warning("%s redeclared to static",
idf->id_text);
-#endif NOROPTION
-#endif LINT
+#endif /* NOROPTION */
+#endif /* LINT */
def->df_sc = STATIC;
}
break;
#ifdef DEBUG
if (options['t'])
dumpidftab("start declare_formals", 0);
-#endif DEBUG
+#endif /* DEBUG */
while (se) {
register struct def *def = se->se_idf->id_def;
case FLOAT:
case DOUBLE:
return reg_float;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case POINTER:
return reg_pointer;
}
#ifndef NOPP
struct macro *id_macro;
int id_resmac; /* if nonzero: keyword of macroproc. */
-#endif NOPP
+#endif /* NOPP */
int id_reserved; /* non-zero for reserved words */
char *id_file; /* file containing the occurrence */
unsigned int id_line; /* line number of the occurrence */
/* defined(??) */
macro_def(str2idf("defined"), "", 1, 1, FUNC);
}
-#endif NOPP
+#endif /* NOPP */
}
int InputLevel;
-#endif NOPP
+#endif /* NOPP */
int NoUnstack;
/* if (NoUnstack) lexwarning("unexpected EOF"); ??? */
DoUnstack();
InputLevel--;
-#endif NOPP
+#endif /* NOPP */
return 0;
}
if (nestlevel != nestlow) lexwarning("missing #endif");
else
-#endif NOPP
+#endif /* NOPP */
if (NoUnstack) lexerror("unexpected EOF");
#ifndef NOPP
nestlevel = nestlow;
#else
#include "l_em.h"
#include "l_lint.h"
-#endif LINT
+#endif /* LINT */
#include "debug.h"
#include <alloc.h>
#include "nobitfield.h"
{
#ifdef LINT
lint_expr(*expp, USED);
-#endif LINT
+#endif /* LINT */
if ((*expp)->ex_type->tp_fund == ARRAY)
array2pointer(*expp);
if (tpp) {
case FIELD:
put_bf(tp, (arith)0);
return;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
default:
break;
}
expr = *expp;
#ifdef DEBUG
print_expr("init-expr after cast", expr);
-#endif DEBUG
+#endif /* DEBUG */
if (!is_ld_cst(expr))
illegal_init_cst(expr);
else
expr = *expp;
#ifdef DEBUG
print_expr("init-expr after cast", expr);
-#endif DEBUG
+#endif /* DEBUG */
if (expr->ex_class == Float)
C_con_fcon(expr->FL_VALUE, expr->ex_type->tp_size);
#ifdef NOTDEF
else
illegal_init_cst(expr);
}
-#endif NOTDEF
+#endif /* NOTDEF */
else
illegal_init_cst(expr);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
#ifndef NOBITFIELD
case FIELD:
expr = *expp;
#ifdef DEBUG
print_expr("init-expr after cast", expr);
-#endif DEBUG
+#endif /* DEBUG */
if (is_cp_cst(expr))
put_bf(tp, expr->VL_VALUE);
else
illegal_init_cst(expr);
break;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
case ERRONEOUS:
if (! gen_error) gen_error = pack_level;
offset = (arith)-1;
}
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
int
zero_bytes(sd)
*newf++ = '\0';
}
-#endif LINT
+#endif /* LINT */
#include "assert.h"
#ifdef ANSI
#include <flt_arith.h>
-#endif ANSI
+#endif /* ANSI */
#include "arith.h" /* definition arith */
#include "label.h" /* definition label */
#include "expr.h"
}
}
-#endif LINT
+#endif /* LINT */
#include "assert.h"
#ifdef ANSI
#include <flt_arith.h>
-#endif ANSI
+#endif /* ANSI */
#include "arith.h" /* definition arith */
#include "label.h" /* definition label */
#include "expr.h"
}
print(">\n");
}
-#endif DEBUG
+#endif /* DEBUG */
-#endif LINT
+#endif /* LINT */
#include "interface.h"
#ifdef ANSI
#include <flt_arith.h>
-#endif ANSI
+#endif /* ANSI */
#include "arith.h" /* definition arith */
#include "label.h" /* definition label */
#include "expr.h"
}
}
-#endif LINT
+#endif /* LINT */
#include "interface.h"
#ifdef ANSI
#include <flt_arith.h>
-#endif ANSI
+#endif /* ANSI */
#include "arith.h"
#include "assert.h"
#include "type.h"
output_def(&od);
/* The other fields are not used for this class. */
}
-#endif IMPLICIT
+#endif /* IMPLICIT */
fill_outcall(ex, used)
struct expr *ex;
/* IFDC, first time */
implicit_func_decl(idf, ex->ex_file, ex->ex_line);
}
-#endif IMPLICIT
+#endif /* IMPLICIT */
OutCall.od_type = def->df_type->tp_up;
OutCall.od_statnr = (def->df_sc == STATIC ? stat_number : 0);
OutCall.od_nrargs++;
}
-#endif LINT
+#endif /* LINT */
#include "debug.h"
#ifdef ANSI
#include <flt_arith.h>
-#endif ANSI
+#endif /* ANSI */
#include "arith.h"
#include "label.h"
#include "expr.h"
#define dbg_lint_stack(m) /*print_lint_stack(m) /* or not */
#else
#define dbg_lint_stack(m)
-#endif DEBUG
+#endif /* DEBUG */
extern char *symbol2str();
extern char *func_name;
case GLOBAL:
#ifdef IMPLICIT
case IMPLICIT:
-#endif IMPLICIT
+#endif /* IMPLICIT */
if (fund == ERRONEOUS)
break;
print(" |--------------\n\n");
}
-#endif DEBUG
+#endif /* DEBUG */
-#endif LINT
+#endif /* LINT */
#define K_UNDEF 10
#define K_PRAGMA 11
#define K_FILE 100 /* for dependency generator */
-#endif NOPP
+#endif /* NOPP */
static File *dep_fd = STDOUT;
extern char *getwdir();
-#endif NOPP
+#endif /* NOPP */
struct sp_id special_ids[] = {
{"setjmp", SP_SETJMP}, /* non-local goto's are registered */
#ifndef NOFLOAT
float_size = SZ_FLOAT,
double_size = SZ_DOUBLE,
-#endif NOFLOAT
+#endif /* NOFLOAT */
pointer_size = SZ_POINTER;
int
#ifndef NOFLOAT
float_align = AL_FLOAT,
double_align = AL_DOUBLE,
-#endif NOFLOAT
+#endif /* NOFLOAT */
pointer_align = AL_POINTER,
struct_align = AL_STRUCT,
union_align = AL_UNION;
-#endif NOCROSS
+#endif /* NOCROSS */
#ifndef NOPP
arith ifval; /* ifval will contain the result of the #if expression */
-#endif NOPP
+#endif /* NOPP */
char *prog_name;
inc_max = 10;
init_pp(); /* initialise the preprocessor macros */
-#endif NOPP
+#endif /* NOPP */
/* Note: source file "-" indicates that the source is supplied
as standard input. This is only allowed if INP_READ_IN_ONE is
*/
#ifdef INP_READ_IN_ONE
while (argc > 1 && *argv[1] == '-')
-#else INP_READ_IN_ONE
+#else /* INP_READ_IN_ONE */
while (argc > 1 && *argv[1] == '-' && argv[1][1] != '\0')
-#endif INP_READ_IN_ONE
+#endif /* INP_READ_IN_ONE */
{
char *par = &argv[1][1];
}
#ifdef LINT
lint_init();
-#endif LINT
+#endif /* LINT */
compile(argc - 1, &argv[1]);
#ifdef DEBUG
hash_stat();
-#endif DEBUG
+#endif /* DEBUG */
#ifndef NOPP
if (do_dependencies) {
else fprint(dep_fd, "%s\n", s);
}
-#endif NOPP
+#endif /* NOPP */
char *source = 0;
char *result;
#ifndef LINT
register char *destination = 0;
-#endif LINT
+#endif /* LINT */
#ifdef DEBUG
#ifndef NOPP
int pp_only = options['E'] || options['P'] || options['C'];
-#endif NOPP
+#endif /* NOPP */
#endif
switch (argc) {
#ifdef DEBUG
#ifndef NOPP
if (!pp_only)
-#endif NOPP
+#endif /* NOPP */
#endif
fatal("%s: destination file not specified", prog_name);
-#endif LINT
+#endif /* LINT */
break;
#ifndef LINT
nmlist = argv[2];
destination = argv[1];
break;
-#endif LINT
+#endif /* LINT */
default:
#ifndef LINT
fatal("use: %s source destination [namelist]", prog_name);
-#else LINT
+#else /* LINT */
fatal("use: %s source", prog_name);
-#endif LINT
+#endif /* LINT */
break;
}
#endif
#ifndef NOPP
WorkingDir = getwdir(source);
-#endif NOPP
+#endif /* NOPP */
PushLex(); /* initialize lex machine */
#ifdef DEBUG
if (pp_only) /* run the preprocessor as if it is stand-alone */
preprocess();
else
-#endif NOPP
-#endif DEBUG
+#endif /* NOPP */
+#endif /* DEBUG */
{
#ifndef LINT
/* compile the source text */
C_program();
#ifdef PREPEND_SCOPES
prepend_scopes();
-#endif PREPEND_SCOPES
+#endif /* PREPEND_SCOPES */
end_code();
-#else LINT
+#else /* LINT */
/* lint the source text */
C_program();
-#endif LINT
+#endif /* LINT */
#ifdef DEBUG
if (options['u']) {
}
if (options['f'] || options['t'])
dumpidftab("end of main", options['f'] ? 0 : 0);
-#endif DEBUG
+#endif /* DEBUG */
}
PopLex();
}
#ifndef NOFLOAT
float_type = standard_type(FLOAT, 0, float_align, float_size);
double_type = standard_type(DOUBLE, 0, double_align, double_size);
-#endif NOFLOAT
+#endif /* NOFLOAT */
void_type = standard_type(VOID, 0, 1, (arith)0);
label_type = standard_type(LABEL, 0, 0, (arith)0);
error_type = standard_type(ERRONEOUS, 0, 1, (arith)1);
#ifndef NOFLOAT
add_def(str2idf("float"), TYPEDEF, float_type, L_UNIVERSAL);
add_def(str2idf("double"), TYPEDEF, double_type, L_UNIVERSAL);
-#endif NOFLOAT
+#endif /* NOFLOAT */
add_def(str2idf("void"), TYPEDEF, void_type, L_UNIVERSAL);
stack_level();
}
case FLOATING:
print("%s ", dot.tk_fval);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
case EOI:
case EOF:
return;
}
}
}
-#endif NOPP
-#endif DEBUG
+#endif /* NOPP */
+#endif /* DEBUG */
No_Mem() /* called by alloc package */
{
int do_dependencies = 0;
char *dep_file = 0;
-#endif NOPP
+#endif /* NOPP */
char options[128]; /* one for every char */
#ifdef LINT
char loptions[128]; /* one for every char */
-#endif LINT
+#endif /* LINT */
extern int idfsize;
extern int density;
default:
#ifndef LINT
fatal("illegal option: %c", opt);
-#else LINT
+#else /* LINT */
warning("illegal option: %c", opt);
-#endif LINT
+#endif /* LINT */
break;
case '-':
#ifndef LINT
#ifdef DATAFLOW
case 'd':
-#endif DATAFLOW
+#endif /* DATAFLOW */
case 'p': /* procentry/procexit */
case 'L' : /* no fil/lin */
case 'n': /* use no registers */
case 'w': /* no warnings will be given */
options[opt] = 1;
goto next_option;
-#endif LINT
+#endif /* LINT */
#ifdef LINT
case 'h': /* heuristic tests */
case 'L': /* lintlibrary */
loptions[opt] = 1;
goto next_option;
-#endif LINT
+#endif /* LINT */
#ifndef LINT
#ifndef NOPP
case 'm':
options[opt] = 1;
break;
-#endif NOPP
-#endif LINT
+#endif /* NOPP */
+#endif /* LINT */
#ifdef DBSYMTAB
case 'g': /* symbol table for debugger */
options['g'] = 1;
case 'R': /* strict version */
#ifndef NOROPTION
options[opt] = 1;
-#else NOROPTION
+#else /* NOROPTION */
warning("-R option not implemented");
-#endif NOROPTION
+#endif /* NOROPTION */
goto next_option;
#ifdef ___XXX___
#ifndef NOPP
options['E'] = 1;
warning("-C: comment is not output");
-#else NOPP
+#else /* NOPP */
warning("-C option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
-#endif ___XXX___
+#endif /* ___XXX___ */
case 'D' : { /* -Dname : predefine name */
#ifndef NOPP
macro_def(str2idf(name), mactext, -1, strlen(mactext),
NOFLAG);
-#else NOPP
+#else /* NOPP */
warning("-D option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
}
case 'E' : /* run preprocessor only, with #<int> */
#ifndef NOPP
options['E'] = 1;
-#else NOPP
+#else /* NOPP */
warning("-E option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
-#endif ___XXX___
+#endif /* ___XXX___ */
case 'I' : /* -Ipath : insert "path" into include list */
#ifndef NOPP
}
}
else inctable[inc_pos] = 0;
-#else NOPP
+#else /* NOPP */
warning("-I option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
case 'M': /* maximum identifier length */
#ifndef NOPP
options['E'] = 1;
options['P'] = 1;
-#else NOPP
+#else /* NOPP */
warning("-P option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
-#endif ___XXX___
+#endif /* ___XXX___ */
#ifdef LINT
case 'S' : { /* -Sint : static scope number for lint */
stat_number = txt2int(&text);
break;
}
-#endif LINT
+#endif /* LINT */
case 'T' : {
#ifdef USE_TMP
C_tmpdir = text;
else
C_tmpdir = ".";
-#else USE_TMP
+#else /* USE_TMP */
warning("-T option ignored");
-#endif USE_TMP
+#endif /* USE_TMP */
break;
}
idef->id_macro = (struct macro *) 0;
}
}
-#else NOPP
+#else /* NOPP */
warning("-U option ignored");
-#endif NOPP
+#endif /* NOPP */
break;
}
#ifdef NOCROSS
warning("-V option ignored");
break;
-#else NOCROSS
+#else /* NOCROSS */
{
register arith sz, algn;
char c;
float_size = sz;
if (algn != 0)
float_align = algn;
-#endif NOFLOAT
+#endif /* NOFLOAT */
break;
case 'd': /* double */
#ifndef NOFLOAT
double_size = sz;
if (algn != 0)
double_align = algn;
-#endif NOFLOAT
+#endif /* NOFLOAT */
break;
case 'p': /* pointer */
if (sz != (arith)0)
case 'r': /* adjust bitfields right */
#ifndef NOBITFIELD
options['r'] = 1;
-#else NOBITFIELD
+#else /* NOBITFIELD */
warning("bitfields are not implemented");
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
break;
case 'S': /* initial struct alignment */
if (sz != (arith)0)
}
break;
}
-#endif NOCROSS
+#endif /* NOCROSS */
case 'S':
density = txt2int(&text);
break;
-#endif LINT
+#endif /* LINT */
}
}
#include "def.h"
#ifdef LINT
#include "l_lint.h"
-#endif LINT
+#endif /* LINT */
#ifndef NOPP
extern arith ifval;
-#endif NOPP
+#endif /* NOPP */
extern error();
}
"sizeof not allowed in preprocessor");
ifval = expr->VL_VALUE;
free_expression(expr);
-#endif NOPP
+#endif /* NOPP */
}
;
declare_idf(&Ds, &Dc, level);
#ifdef LINT
lint_ext_def(Dc.dc_idf, Ds.ds_sc);
-#endif LINT
+#endif /* LINT */
}
[
function(&Ds, &Dc)
{
#ifdef LINT
lint_non_function_decl(ds, dc);
-#endif LINT
+#endif /* LINT */
}
[
','
{ register struct idf *idf = dc->dc_idf;
#ifdef LINT
lint_start_function();
-#endif LINT
+#endif /* LINT */
init_idf(idf);
stack_level(); /* L_FORMAL1 declarations */
declare_params(dc);
declare_formals(&fbytes);
#ifdef LINT
lint_formals();
-#endif LINT
+#endif /* LINT */
}
compound_statement
{
end_proc(fbytes);
#ifdef LINT
lint_implicit_return();
-#endif LINT
+#endif /* LINT */
unstack_level(); /* L_FORMAL2 declarations */
#ifdef LINT
lint_end_formals();
-#endif LINT
+#endif /* LINT */
unstack_level(); /* L_FORMAL1 declarations */
#ifdef LINT
lint_end_function();
-#endif LINT
+#endif /* LINT */
}
;
}
Unstacked = 0;
}
-#endif NOPP
+#endif /* NOPP */
case ']':
lexerror("unbalanced parenthesis");
break;
-#endif __MATCHING_PAR__
+#endif /* __MATCHING_PAR__ */
case '(':
copyact('(', ')', lvl+1);
case '[':
copyact('[', ']', lvl+1);
break;
-#endif __MATCHING_PAR__
+#endif /* __MATCHING_PAR__ */
case '\n':
LineNumber++;
}
}
}
-#endif NOPP
+#endif /* NOPP */
short_size, word_size, dword_size, int_size, long_size,
#ifndef NOFLOAT
float_size, double_size,
-#endif NOFLOAT
+#endif /* NOFLOAT */
pointer_size;
-#else NOCROSS
+#else /* NOCROSS */
#define short_size (SZ_SHORT)
#define word_size (SZ_WORD)
#define dword_size (2*SZ_WORD)
#ifndef NOFLOAT
#define float_size (SZ_FLOAT)
#define double_size (SZ_DOUBLE)
-#endif NOFLOAT
+#endif /* NOFLOAT */
#define pointer_size (SZ_POINTER)
-#endif NOCROSS
+#endif /* NOCROSS */
extern arith max_int, max_unsigned; /* cstoper.c */
return ch;
}
}
-#endif NOPP
+#endif /* NOPP */
PRIVATE
skipline()
#include <em.h>
#else
#include "l_em.h"
-#endif LINT
+#endif /* LINT */
#include "debug.h"
#include "botch_free.h"
#include <alloc.h>
local_level = stl;
#ifdef LINT
lint_start_local();
-#endif LINT
+#endif /* LINT */
}
stack_idf(idf, stl)
#ifdef DEBUG
if (options['t'])
dumpidftab("before unstackidfs", 0);
-#endif DEBUG
+#endif /* DEBUG */
#ifdef LINT
lint_end_local(local_level);
-#endif LINT
+#endif /* LINT */
/* The implementation below is more careful than strictly
necessary. Optimists may optimize it afterwards.
#ifdef DEBUG
if (options['t'])
dumpidftab("after unstackidfs", 0);
-#endif DEBUG
+#endif /* DEBUG */
}
unstack_world()
#ifdef LINT
lint_end_global(local_level);
-#endif LINT
+#endif /* LINT */
open_name_list();
def->df_initialized ? "init" : "no init",
def->df_used ? "used" : "not used");
}
-#endif DEBUG
+#endif /* DEBUG */
/*
/_* find final storage class *_/
if (def->df_sc == GLOBAL || def->df_sc == IMPLICIT)
#else
#include "l_em.h"
#include "l_lint.h"
-#endif LINT
+#endif /* LINT */
#include "debug.h"
#include "botch_free.h"
{
#ifdef LINT
lint_statement();
-#endif LINT
+#endif /* LINT */
}
:
%if (AHEAD != ':')
code_break();
#ifdef LINT
lint_break_stmt();
-#endif LINT
+#endif /* LINT */
}
';'
|
code_continue();
#ifdef LINT
lint_continue_stmt();
-#endif LINT
+#endif /* LINT */
}
';'
|
{
#ifdef DEBUG
print_expr("expression_statement", expr);
-#endif DEBUG
+#endif /* DEBUG */
code_expr(expr, RVAL, FALSE, NO_LABEL, NO_LABEL);
free_expression(expr);
}
*/
#ifdef LINT
lint_label();
-#endif LINT
+#endif /* LINT */
define_label(idf);
C_df_ilb((label)idf->id_def->df_address);
}
/* else fall through */
#ifdef LINT
start_if_part(1);
-#endif LINT
+#endif /* LINT */
}
else {
code_expr(expr, RVAL, TRUE, l_true, l_false);
C_df_ilb(l_true);
#ifdef LINT
start_if_part(0);
-#endif LINT
+#endif /* LINT */
}
free_expression(expr);
}
{
#ifdef LINT
start_else_part();
-#endif LINT
+#endif /* LINT */
C_bra(l_end);
C_df_ilb(l_false);
}
{ C_df_ilb(l_end);
#ifdef LINT
end_if_else_stmt();
-#endif LINT
+#endif /* LINT */
}
|
empty
{ C_df_ilb(l_false);
#ifdef LINT
end_if_stmt();
-#endif LINT
+#endif /* LINT */
}
]
;
#ifdef LINT
start_while_stmt(expr);
-#endif LINT
+#endif /* LINT */
}
')'
#ifdef LINT
end_loop_body();
end_loop_stmt();
-#endif LINT
+#endif /* LINT */
}
;
stack_stmt(l_break, l_continue);
#ifdef LINT
start_do_stmt();
-#endif LINT
+#endif /* LINT */
}
statement
WHILE
{
#ifdef LINT
end_loop_body();
-#endif LINT
+#endif /* LINT */
C_df_ilb(l_continue);
}
expression(&expr)
}
#ifdef LINT
end_do_stmt(1, expr->VL_VALUE != (arith)0);
-#endif LINT
+#endif /* LINT */
}
else {
code_expr(expr, RVAL, TRUE, l_body, l_break);
#ifdef LINT
end_do_stmt(0, 0);
-#endif LINT
+#endif /* LINT */
}
C_df_ilb(l_break);
}
{
#ifdef LINT
start_for_stmt(e_test);
-#endif LINT
+#endif /* LINT */
}
statement
{
#ifdef LINT
end_loop_body();
-#endif LINT
+#endif /* LINT */
C_df_ilb(l_continue);
if (e_incr)
code_expr(e_incr, RVAL, FALSE,
free_expression(e_incr);
#ifdef LINT
end_loop_stmt();
-#endif LINT
+#endif /* LINT */
}
;
code_startswitch(&expr);
#ifdef LINT
start_switch_part(is_cp_cst(expr));
-#endif LINT
+#endif /* LINT */
}
')'
statement
{
#ifdef LINT
end_switch_stmt();
-#endif LINT
+#endif /* LINT */
code_endswitch();
free_expression(expr);
}
{
#ifdef LINT
lint_case_stmt(0);
-#endif LINT
+#endif /* LINT */
code_case(expr);
free_expression(expr);
}
{
#ifdef LINT
lint_case_stmt(1);
-#endif LINT
+#endif /* LINT */
code_default();
}
':'
{
#ifdef LINT
lint_ret_conv(expr);
-#endif LINT
+#endif /* LINT */
do_return_expr(expr);
free_expression(expr);
#ifdef LINT
lint_return_stmt(VALRETURNED);
-#endif LINT
+#endif /* LINT */
}
|
empty
do_return();
#ifdef LINT
lint_return_stmt(NOVALRETURNED);
-#endif LINT
+#endif /* LINT */
}
]
';'
C_bra((label)idf->id_def->df_address);
#ifdef LINT
lint_jump_stmt(idf);
-#endif LINT
+#endif /* LINT */
}
;
arith offset;
#ifndef NOBITFIELD
extern arith add_field();
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
struct tag *tg = stp->tp_idf->id_struct; /* or union */
struct sdef *sdef = idf->id_sdef;
*/
offset = add_field(szp, fd, &tp, idf, stp);
}
-#else NOBITFIELD
+#else /* NOBITFIELD */
offset = align(*szp, tp->tp_align);
field_busy = 0;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
}
else { /* (stp->tp_fund == UNION) */
if (fd) {
#ifndef NOBITFIELD
if (tp->tp_fund == FIELD)
tp->tp_field->fd_sdef = newsdef;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
stack_idf(idf, stack_level_of(lvl));
return field_offset;
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
/* some utilities */
int
#include <em.h>
#else
#include "l_em.h"
-#endif LINT
+#endif /* LINT */
#include "debug.h"
#include "botch_free.h"
#include <alloc.h>
error("float/double in switch");
erroneous2int(expp);
break;
-#endif NOFLOAT
+#endif /* NOFLOAT */
}
stack_stmt(l_break, NO_LABEL);
sh->sh_break = l_break;
{FLOATING, "floating"},
{0, ""}
};
-#endif ____
+#endif /* ____ */
#ifdef ____
struct tokenname tkcomp[] = { /* names of the composite tokens */
{OR, "||"},
{0, ""}
};
-#endif ____
+#endif /* ____ */
struct tokenname tkidf[] = { /* names of the identifier tokens */
{ASM, "asm"},
{FLOAT2FLOAT, "float2float"},
{0, ""}
};
-#endif ____
+#endif /* ____ */
reserve(resv)
register struct tokenname resv[];
struct type *function_of(), *array_of();
#ifndef NOBITFIELD
struct type *field_of();
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
/* To be created dynamically in main() from defaults or from command
line parameters.
*long_type, *ulong_type,
#ifndef NOFLOAT
*float_type, *double_type,
-#endif NOFLOAT
+#endif /* NOFLOAT */
*void_type, *label_type,
*string_type, *funint_type, *error_type;
case FIELD:
dtp = field_of(tp);
break;
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
case FUNCTION:
if (tp->tp_fund == FUNCTION) {
dtp->tp_size = tp->tp_size;
return dtp;
}
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
arith
size_of_type(tp, nm)
#ifndef NOBITFIELD
extern struct type *field_of();
-#endif NOBITFIELD
+#endif /* NOBITFIELD */
extern struct type
*char_type, *uchar_type,
*long_type, *ulong_type,
#ifndef NOFLOAT
*float_type, *double_type,
-#endif NOFLOAT
+#endif /* NOFLOAT */
*void_type, *label_type,
*string_type, *funint_type, *error_type;
#include <em.h>
#else
#include "l_em.h"
-#endif LINT
+#endif /* LINT */
#include <em_arith.h>
#include <em_reg.h>
#include <alloc.h>
static struct localvar *FreeTmps;
#ifdef USE_TMP
static int loc_id;
-#endif USE_TMP
+#endif /* USE_TMP */
#ifdef PEEPHOLE
#undef REGCOUNT
{
#ifdef USE_TMP
C_insertpart(loc_id = C_getid());
-#endif USE_TMP
+#endif /* USE_TMP */
}
arith
if (p) p->t_regtype = -1;
C_lal(off);
}
-#endif LINT
+#endif /* LINT */
{ERRONEOUS, "erroneous"},
{0, ""}
};
-#endif ____
+#endif /* ____ */
public / ack.git / commitdiff