d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Run through clang-format.

Browse source
This commit is contained in:
David Given 2017-01-08 11:23:56 +01:00
parent 62022c6f6b
commit ee5ef73dfb
1 changed files with 470 additions and 392 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

412
lang/m2/comp/walk.c
View file

@ -76,7 +76,8 @@ void DoAssign();
int
LblWalkNode(lbl, nd, exit, reach)
label lbl, exit;
label lbl,
exit;
t_node* nd;
{
/* Generate code for node "nd", after generating instruction
@ -96,7 +97,8 @@ DoPriority()
/* For the time being (???), handle priorities by calls to
the runtime system
*/
if (priority) {
if (priority)
{
tmpprio = NewInt();
C_loc(priority->nd_INT);
CAL("stackprio", (int)word_size);
@ -108,7 +110,8 @@ DoPriority()
STATIC
EndPriority()
{
if (priority) {
if (priority)
{
C_lol(tmpprio);
CAL("unstackprio", (int)word_size);
FreeInt(tmpprio);
@ -124,8 +127,7 @@ def_ilb(l)
oldlineno = 0;
}
DoLineno(nd)
register t_node *nd;
DoLineno(nd) register t_node* nd;
{
/* Generate line number information, if necessary.
*/
@ -133,16 +135,19 @@ DoLineno(nd)
#ifdef DBSYMTAB
|| options['g']
#endif /* DBSYMTAB */
) &&
nd->nd_lineno &&
nd->nd_lineno != oldlineno) {
)
&& nd->nd_lineno && nd->nd_lineno != oldlineno)
{
oldlineno = nd->nd_lineno;
if (! options['L']) C_lin((arith) nd->nd_lineno);
if (!options['L'])
C_lin((arith)nd->nd_lineno);
#ifdef DBSYMTAB
if ( options['g']) {
if (options['g'])
{
static int ms_lineno;
if (ms_lineno != nd->nd_lineno) {
if (ms_lineno != nd->nd_lineno)
{
ms_lineno = nd->nd_lineno;
C_ms_std((char*)0, N_SLINE, ms_lineno);
}
@ -161,9 +166,11 @@ DoFilename(needed)
static label filename_label = 0;
oldlineno = 0; /* always invalidate remembered line number */
if (needed && ! options['L']) {
if (needed && !options['L'])
{
if (! filename_label) {
if (!filename_label)
{
filename_label = 1;
C_df_dlb((label)1);
C_rom_scon(FileName, (arith)(strlen(FileName) + 1));
@ -173,8 +180,7 @@ DoFilename(needed)
}
}
WalkModule(module)
register t_def *module;
WalkModule(module) register t_def* module;
{
/* Walk through a module, and all its local definitions.
Also generate code for its body.
@ -200,10 +206,12 @@ WalkModule(module)
TmpOpen(sc); /* Initialize for temporaries */
C_pro_narg(sc->sc_name);
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
stb_string(module, D_MODULE);
WalkDefList(sc->sc_def, stabdef);
if (state == PROGRAM && module == Defined) {
if (state == PROGRAM && module == Defined)
{
C_ms_stb_cst(module->df_idf->id_text,
N_MAIN,
0,
@ -213,14 +221,16 @@ WalkModule(module)
}
#endif
DoPriority();
if (module == Defined) {
if (module == Defined)
{
/* Body of implementation or program module.
Call initialization routines of imported modules.
Also prevent recursive calls of this one.
*/
register t_node* nd = Modules;
if (state == IMPLEMENTATION) {
if (state == IMPLEMENTATION)
{
/* We don't actually prevent recursive calls,
but do nothing if called recursively
*/
@ -233,14 +243,16 @@ WalkModule(module)
C_zne(RETURN_LABEL);
C_ine_dlb(data_label, (arith)0);
}
else if (! options['R']) {
else if (!options['R'])
{
/* put funny value in BSS, in an attempt to detect
uninitialized variables
*/
C_cal("killbss");
}
for (; nd; nd = nd->nd_NEXT) {
for (; nd; nd = nd->nd_NEXT)
{
C_cal(nd->nd_def->mod_vis->sc_scope->sc_name);
}
DoFilename(1);
@ -248,7 +260,8 @@ WalkModule(module)
WalkDefList(sc->sc_def, MkCalls);
proclevel++;
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
C_ms_std((char*)0, N_LBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
@ -258,7 +271,8 @@ WalkModule(module)
EndPriority();
C_ret((arith)0);
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
C_ms_std((char*)0, N_RBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
@ -270,8 +284,7 @@ WalkModule(module)
WalkDefList(sc->sc_def, UseWarnings);
}
WalkProcedure(procedure)
register t_def *procedure;
WalkProcedure(procedure) register t_def* procedure;
{
/* Walk through the definition of a procedure and all its
local definitions, checking and generating code.
@ -301,9 +314,11 @@ WalkProcedure(procedure)
func_type = tp = RemoveEqual(ResultType(procedure->df_type));
if (tp) {
if (tp)
{
func_res_size = WA(tp->tp_size);
if (TooBigForReturnArea(tp)) {
if (TooBigForReturnArea(tp))
{
#ifdef BIG_RESULT_ON_STACK
/* The result type of this procedure is too big.
The caller will have reserved space on its stack,
@ -334,7 +349,8 @@ WalkProcedure(procedure)
#else
C_pro_narg(procedure->prc_name);
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
stb_string(procedure, D_PROCEDURE);
WalkDefList(procscope->sc_def, stabdef);
stb_string(procedure, D_PEND);
@ -360,14 +376,18 @@ WalkProcedure(procedure)
/* Check if we must save the stack pointer */
for (param = ParamList(procedure->df_type);
param;
param = param->par_next) {
if (! IsVarParam(param)) {
param = param->par_next)
{
if (!IsVarParam(param))
{
tp = TypeOfParam(param);
if ( IsConformantArray(tp)) {
if (IsConformantArray(tp))
{
/* First time we get here
*/
if (func_type && !too_big) {
if (func_type && !too_big)
{
/* Some local space, only
needed if the value itself
is returned
@ -390,8 +410,10 @@ WalkProcedure(procedure)
def_ilb(cd_body);
#endif
if ((WalkNode(procedure->prc_body, NO_EXIT_LABEL, REACH_FLAG) & REACH_FLAG)) {
if (func_res_size) {
if ((WalkNode(procedure->prc_body, NO_EXIT_LABEL, REACH_FLAG) & REACH_FLAG))
{
if (func_res_size)
{
node_warning(procscope->sc_end,
W_ORDINARY,
"function procedure \"%s\" does not always return a value",
@ -422,13 +444,16 @@ WalkProcedure(procedure)
*/
for (param = ParamList(procedure->df_type);
param;
param = param->par_next) {
if (! IsVarParam(param)) {
param = param->par_next)
{
if (!IsVarParam(param))
{
tp = TypeOfParam(param);
if (! IsConformantArray(tp)) {
if (tp->tp_size < word_size &&
(int) word_size % (int) tp->tp_size == 0) {
if (!IsConformantArray(tp))
{
if (tp->tp_size < word_size && (int)word_size % (int)tp->tp_size == 0)
{
C_lol(param->par_def->var_off);
STL(param->par_def->var_off,
tp->tp_size);
@ -464,7 +489,8 @@ WalkProcedure(procedure)
#endif
DO_DEBUG(options['X'], PrNode(procedure->prc_body, 0));
def_ilb(RETURN_LABEL); /* label at end */
if (too_big) {
if (too_big)
{
/* Fill the data area reserved for the function result
with the result
*/
@ -474,7 +500,8 @@ WalkProcedure(procedure)
c_lae_dlb(too_big);
#endif /* BIG_RESULT_ON_STACK */
C_sti(func_res_size);
if (StackAdjustment) {
if (StackAdjustment)
{
/* Remove copies of conformant arrays
*/
LOL(StackAdjustment, pointer_size);
@ -487,17 +514,20 @@ WalkProcedure(procedure)
func_res_size = pointer_size;
#endif /* BIG_RESULT_ON_STACK */
}
else if (StackAdjustment) {
else if (StackAdjustment)
{
/* First save the function result in a safe place.
Then remove copies of conformant arrays,
and put function result back on the stack
*/
if (func_type) {
if (func_type)
{
STL(retsav, func_res_size);
}
LOL(StackAdjustment, pointer_size);
C_str((arith)1);
if (func_type) {
if (func_type)
{
LOL(retsav, func_res_size);
}
}
@ -507,7 +537,8 @@ WalkProcedure(procedure)
C_beginpart(partno2);
C_pro(procedure->prc_name, -procscope->sc_off);
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
stb_string(procedure, D_PROCEDURE);
WalkDefList(procscope->sc_def, stabdef);
stb_string(procedure, D_PEND);
@ -520,17 +551,20 @@ WalkProcedure(procedure)
#endif
);
#endif
if (! options['n']) WalkDefList(procscope->sc_def, RegisterMessage);
if (!options['n'])
WalkDefList(procscope->sc_def, RegisterMessage);
#ifdef USE_INSERT
C_endpart(partno2);
#endif
#ifdef DBSYMTAB
if (options['g']) {
if (options['g'])
{
C_ms_std((char*)0, N_RBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
C_end(-procscope->sc_off);
if (! fit(procscope->sc_off, (int) word_size)) {
if (!fit(procscope->sc_off, (int)word_size))
{
node_error(procedure->prc_body,
"maximum local byte count exceeded");
}
@ -540,14 +574,13 @@ WalkProcedure(procedure)
WalkDefList(procscope->sc_def, UseWarnings);
}
static
WalkDef(df)
register t_def *df;
static WalkDef(df) register t_def* df;
{
/* Walk through a list of definitions
*/
switch(df->df_kind) {
switch (df->df_kind)
{
case D_MODULE:
WalkModule(df);
break;
@ -555,7 +588,8 @@ WalkDef(df)
WalkProcedure(df);
break;
case D_VARIABLE:
if (!proclevel && !(df->df_flags & D_ADDRGIVEN)) {
if (!proclevel && !(df->df_flags & D_ADDRGIVEN))
{
C_df_dnam(df->var_name);
C_bss_cst(
WA(df->df_type->tp_size),
@ -568,21 +602,19 @@ WalkDef(df)
}
}
static
MkCalls(df)
register t_def *df;
static MkCalls(df) register t_def* df;
{
/* Generate calls to initialization routines of modules
*/
if (df->df_kind == D_MODULE) {
if (df->df_kind == D_MODULE)
{
C_lxl((arith)0);
CAL(df->mod_vis->sc_scope->sc_name, (int)pointer_size);
}
}
WalkLink(nd, exit_label, end_reached)
register t_node *nd;
WalkLink(nd, exit_label, end_reached) register t_node* nd;
label exit_label;
{
/* Walk node "nd", which is a link.
@ -591,7 +623,8 @@ WalkLink(nd, exit_label, end_reached)
and whether an EXIT statement was seen (EXIT_FLAG).
*/
while (nd && nd->nd_class == Link) { /* statement list */
while (nd && nd->nd_class == Link)
{ /* statement list */
end_reached = WalkNode(nd->nd_LEFT, exit_label, end_reached);
nd = nd->nd_RIGHT;
}
@ -600,8 +633,7 @@ WalkLink(nd, exit_label, end_reached)
}
STATIC
ForLoopVarExpr(nd)
register t_node *nd;
ForLoopVarExpr(nd) register t_node* nd;
{
register t_type* tp = nd->nd_type;
@ -610,8 +642,7 @@ ForLoopVarExpr(nd)
}
int
WalkStat(nd, exit_label, end_reached)
register t_node *nd;
WalkStat(nd, exit_label, end_reached) register t_node* nd;
label exit_label;
{
/* Walk through a statement, generating code for it.
@ -621,24 +652,30 @@ WalkStat(nd, exit_label, end_reached)
assert(nd->nd_class == Stat);
if (nd->nd_symb == ';') return 1;
if (nd->nd_symb == ';')
return 1;
if (! end_reached & REACH_FLAG) {
if (!end_reached & REACH_FLAG)
{
node_warning(nd, W_ORDINARY, "statement not reached");
}
if (nd->nd_symb != WHILE ||
nd->nd_lineno != left->nd_lineno) {
if (nd->nd_symb != WHILE || nd->nd_lineno != left->nd_lineno)
{
/* Avoid double linenumber generation in while statements */
DoLineno(nd);
}
options['R'] = (nd->nd_flags & ROPTION);
options['A'] = (nd->nd_flags & AOPTION);
switch(nd->nd_symb) {
case '(': {
switch (nd->nd_symb)
{
case '(':
{
t_node* nd1 = nd;
if (ChkCall(&nd1)) {
if (ChkCall(&nd1))
{
assert(nd == nd1);
if (nd->nd_type != 0) {
if (nd->nd_type != 0)
{
node_error(nd, "procedure call expected instead of function call");
break;
}
@ -652,21 +689,24 @@ WalkStat(nd, exit_label, end_reached)
break;
case IF:
{ label l1 = ++text_label, l3 = ++text_label;
{
label l1 = ++text_label, l3 = ++text_label;
int end_r;
ExpectBool(&(nd->nd_LEFT), l3, l1);
assert(right->nd_symb == THEN);
end_r = LblWalkNode(l3, right->nd_LEFT, exit_label, end_reached);
if (right->nd_RIGHT) { /* ELSE part */
if (right->nd_RIGHT)
{ /* ELSE part */
label l2 = ++text_label;
c_bra(l2);
end_reached = end_r | LblWalkNode(l1, right->nd_RIGHT, exit_label, end_reached);
l1 = l2;
}
else end_reached |= end_r;
else
end_reached |= end_r;
def_ilb(l1);
break;
}
@ -676,7 +716,8 @@ WalkStat(nd, exit_label, end_reached)
break;
case WHILE:
{ label loop = ++text_label,
{
label loop = ++text_label,
exit = ++text_label,
dummy = ++text_label;
@ -689,7 +730,8 @@ WalkStat(nd, exit_label, end_reached)
}
case REPEAT:
{ label loop = ++text_label, exit = ++text_label;
{
label loop = ++text_label, exit = ++text_label;
end_reached = LblWalkNode(loop, left, exit_label, end_reached);
ExpectBool(&(nd->nd_RIGHT), exit, loop);
@ -698,12 +740,15 @@ WalkStat(nd, exit_label, end_reached)
}
case LOOP:
{ label loop = ++text_label, exit = ++text_label;
{
label loop = ++text_label, exit = ++text_label;
if (LblWalkNode(loop, right, exit, end_reached) & EXIT_FLAG) {
if (LblWalkNode(loop, right, exit, end_reached) & EXIT_FLAG)
{
end_reached &= REACH_FLAG;
}
else end_reached = 0;
else
end_reached = 0;
c_bra(loop);
def_ilb(exit);
break;
@ -723,12 +768,14 @@ WalkStat(nd, exit_label, end_reached)
good_forvar = DoForInit(left);
loopid = left->nd_LEFT;
if ((stepsize = right->nd_LEFT->nd_INT) == 0) {
if ((stepsize = right->nd_LEFT->nd_INT) == 0)
{
node_warning(right->nd_LEFT,
W_ORDINARY,
"zero stepsize in FOR loop");
}
if (good_forvar) {
if (good_forvar)
{
bstp = BaseType(loopid->nd_type);
uns = bstp->tp_fund != T_INTEGER;
CodePExpr(left->nd_RIGHT->nd_RIGHT);
@ -737,37 +784,46 @@ WalkStat(nd, exit_label, end_reached)
C_dup(int_size);
C_stl(tmp2);
C_lol(tmp);
if (uns) C_cmu(int_size);
else C_cmi(int_size);
if (stepsize >= 0) C_zgt(l2);
else C_zlt(l2);
if (uns)
C_cmu(int_size);
else
C_cmi(int_size);
if (stepsize >= 0)
C_zgt(l2);
else
C_zlt(l2);
C_lol(tmp2);
RangeCheck(loopid->nd_type,
left->nd_RIGHT->nd_LEFT->nd_type);
CodeDStore(loopid);
if (stepsize >= 0) {
if (stepsize >= 0)
{
C_lol(tmp);
ForLoopVarExpr(loopid);
}
else {
else
{
stepsize = -stepsize;
ForLoopVarExpr(loopid);
C_lol(tmp);
}
C_sbu(int_size);
if (stepsize) {
if (stepsize)
{
C_loc(stepsize);
C_dvu(int_size);
}
C_stl(tmp);
loopid->nd_def->df_flags |= D_FORLOOP;
def_ilb(l1);
if (! options['R']) {
if (!options['R'])
{
ForLoopVarExpr(loopid);
C_stl(tmp2);
}
end_reached |= WalkNode(right->nd_RIGHT, exit_label, end_reached);
if (! options['R']) {
if (!options['R'])
{
label x = ++text_label;
C_lol(tmp2);
ForLoopVarExpr(loopid);
@ -778,7 +834,8 @@ WalkStat(nd, exit_label, end_reached)
}
loopid->nd_def->df_flags &= ~D_FORLOOP;
FreeInt(tmp2);
if (stepsize) {
if (stepsize)
{
C_lol(tmp);
C_zeq(l2);
C_lol(tmp);
@ -792,7 +849,8 @@ WalkStat(nd, exit_label, end_reached)
CodeDStore(loopid);
}
}
else {
else
{
end_reached |= WalkNode(right->nd_RIGHT, exit_label, end_reached);
loopid->nd_def->df_flags &= ~D_FORLOOP;
}
@ -808,9 +866,11 @@ WalkStat(nd, exit_label, end_reached)
struct withdesig wds;
t_desig ds;
if (! WalkDesignator(&(nd->nd_LEFT), &ds, D_USED)) break;
if (!WalkDesignator(&(nd->nd_LEFT), &ds, D_USED))
break;
left = nd->nd_LEFT;
if (left->nd_type->tp_fund != T_RECORD) {
if (left->nd_type->tp_fund != T_RECORD)
{
node_error(left, "record variable expected");
break;
}
@ -843,26 +903,32 @@ WalkStat(nd, exit_label, end_reached)
case EXIT:
assert(exit_label != 0);
if (end_reached & REACH_FLAG) end_reached = EXIT_FLAG;
if (end_reached & REACH_FLAG)
end_reached = EXIT_FLAG;
c_bra(exit_label);
break;
case RETURN:
end_reached &= ~REACH_FLAG;
if (right) {
if (! ChkExpression(&(nd->nd_RIGHT))) break;
if (right)
{
if (!ChkExpression(&(nd->nd_RIGHT)))
break;
/* The type of the return-expression must be
assignment compatible with the result type of the
function procedure (See Rep. 9.11).
*/
if (!ChkAssCompat(&(nd->nd_RIGHT), func_type, "RETURN")) {
if (!ChkAssCompat(&(nd->nd_RIGHT), func_type, "RETURN"))
{
break;
}
right = nd->nd_RIGHT;
if (right->nd_type->tp_fund == T_STRING) {
if (right->nd_type->tp_fund == T_STRING)
{
CodePString(right, func_type);
}
else CodePExpr(right);
else
CodePExpr(right);
}
c_bra(RETURN_LABEL);
break;
@ -893,8 +959,7 @@ int (*WalkTable[])() = {
extern t_desig null_desig;
ExpectBool(pnd, true_label, false_label)
register t_node **pnd;
ExpectBool(pnd, true_label, false_label) register t_node** pnd;
label true_label, false_label;
{
/* "pnd" must indicate a boolean expression. Check this and
@ -903,9 +968,10 @@ ExpectBool(pnd, true_label, false_label)
t_desig ds;
ds = null_desig;
if (ChkExpression(pnd)) {
if ((*pnd)->nd_type != bool_type &&
(*pnd)->nd_type != error_type) {
if (ChkExpression(pnd))
{
if ((*pnd)->nd_type != bool_type && (*pnd)->nd_type != error_type)
{
node_error(*pnd, "boolean expression expected");
}
@ -921,7 +987,8 @@ WalkDesignator(pnd, ds, flags)
/* Check designator and generate code for it
*/
if (! ChkVariable(pnd, flags)) return 0;
if (!ChkVariable(pnd, flags))
return 0;
*ds = null_desig;
CodeDesig(*pnd, ds);
@ -940,36 +1007,43 @@ DoForInit(nd)
r = ChkVariable(&(nd->nd_LEFT), D_USED | D_DEFINED);
r &= ChkExpression(&(right->nd_LEFT));
r &= ChkExpression(&(right->nd_RIGHT));
if (!r) return 0;
if (!r)
return 0;
df = nd->nd_LEFT->nd_def;
if (df->df_kind == D_FIELD) {
if (df->df_kind == D_FIELD)
{
node_error(nd,
"FOR-loop variable may not be a field of a record");
return 1;
}
if (!df->var_name && df->var_off >= 0) {
if (!df->var_name && df->var_off >= 0)
{
node_error(nd, "FOR-loop variable may not be a parameter");
return 1;
}
if (df->df_scope != CurrentScope) {
if (df->df_scope != CurrentScope)
{
register t_scopelist* sc = CurrVis;
for (;;) {
if (!sc) {
for (;;)
{
if (!sc)
{
node_error(nd,
"FOR-loop variable may not be imported");
return 1;
}
if (sc->sc_scope == df->df_scope) break;
if (sc->sc_scope == df->df_scope)
break;
sc = nextvisible(sc);
}
}
if (df->df_type->tp_size > word_size ||
!(df->df_type->tp_fund & T_DISCRETE)) {
if (df->df_type->tp_size > word_size || !(df->df_type->tp_fund & T_DISCRETE))
{
node_error(nd, "illegal type of FOR loop variable");
return 1;
}
@ -978,19 +1052,21 @@ DoForInit(nd)
tpl = right->nd_LEFT->nd_type;
tpr = right->nd_RIGHT->nd_type;
#ifndef STRICT_3RD_ED
if (! options['3']) {
if (!ChkAssCompat(&(right->nd_LEFT), base_tp, "FOR statement") ||
!ChkAssCompat(&(right->nd_RIGHT), base_tp, "FOR statement")) {
if (!options['3'])
{
if (!ChkAssCompat(&(right->nd_LEFT), base_tp, "FOR statement") || !ChkAssCompat(&(right->nd_RIGHT), base_tp, "FOR statement"))
{
return 1;
}
if (!TstCompat(df->df_type, tpl) ||
!TstCompat(df->df_type, tpr)) {
if (!TstCompat(df->df_type, tpl) || !TstCompat(df->df_type, tpr))
{
node_warning(nd, W_OLDFASHIONED, "compatibility required in FOR statement");
}
} else
}
else
#endif
if (!ChkCompat(&(right->nd_LEFT), base_tp, "FOR statement") ||
!ChkCompat(&(right->nd_RIGHT), base_tp, "FOR statement")) {
if (!ChkCompat(&(right->nd_LEFT), base_tp, "FOR statement") || !ChkCompat(&(right->nd_RIGHT), base_tp, "FOR statement"))
{
return 1;
}
@ -998,8 +1074,7 @@ node_warning(nd, W_OLDFASHIONED, "compatibility required in FOR statement");
}
void
DoAssign(nd)
register t_node *nd;
DoAssign(nd) register t_node* nd;
{
/* May we do it in this order (expression first) ???
The reference manual sais nothing about it, but the book does:
@ -1009,11 +1084,12 @@ DoAssign(nd)
t_desig dsr;
register t_type* tp;
if (! (ChkExpression(&(nd->nd_RIGHT)) &
ChkVariable(&(nd->nd_LEFT), D_DEFINED))) return;
if (!(ChkExpression(&(nd->nd_RIGHT)) & ChkVariable(&(nd->nd_LEFT), D_DEFINED)))
return;
tp = nd->nd_LEFT->nd_type;
if (! ChkAssCompat(&(nd->nd_RIGHT), tp, "assignment")) {
if (!ChkAssCompat(&(nd->nd_RIGHT), tp, "assignment"))
{
return;
}
dsr = null_desig;
@ -1022,38 +1098,41 @@ DoAssign(nd)
|| (ds).dsg_kind == DSG_INDEXED)
CodeExpr(nd->nd_RIGHT, &dsr, NO_LABEL, NO_LABEL);
tp = nd->nd_RIGHT->nd_type;
if (complex(tp)) {
if (StackNeededFor(dsr)) CodeAddress(&dsr);
if (complex(tp))
{
if (StackNeededFor(dsr))
CodeAddress(&dsr);
}
else {
else
{
CodeValue(&dsr, tp);
}
CodeMove(&dsr, nd->nd_LEFT, tp);
}
static
RegisterMessage(df)
register t_def *df;
static RegisterMessage(df) register t_def* df;
{
register t_type* tp;
if (df->df_kind == D_VARIABLE) {
if ( !(df->df_flags & D_NOREG)) {
if (df->df_kind == D_VARIABLE)
{
if (!(df->df_flags & D_NOREG))
{
/* Examine type and size
*/
tp = BaseType(df->df_type);
if ((df->df_flags & D_VARPAR) ||
(tp->tp_fund&(T_POINTER|T_HIDDEN|T_EQUAL))) {
if ((df->df_flags & D_VARPAR) || (tp->tp_fund & (T_POINTER | T_HIDDEN | T_EQUAL)))
{
C_ms_reg(df->var_off,
pointer_size,
reg_pointer,
0);
}
else if (tp->tp_fund & T_NUMERIC) {
else if (tp->tp_fund & T_NUMERIC)
{
C_ms_reg(df->var_off,
tp->tp_size,
tp->tp_fund == T_REAL ?
reg_float : reg_any,
tp->tp_fund == T_REAL ? reg_float : reg_any,
0);
}
}
@ -1066,55 +1145,53 @@ df_warning(nd, df, warning)
t_def* df;
char* warning;
{
if (! (df->df_kind & (D_VARIABLE|D_PROCEDURE|D_TYPE|D_CONST|D_PROCHEAD))) {
if (!(df->df_kind & (D_VARIABLE | D_PROCEDURE | D_TYPE | D_CONST | D_PROCHEAD)))
{
return;
}
if (warning) {
if (warning)
{
node_warning(nd,
W_ORDINARY,
"%s \"%s\" %s",
(df->df_flags & D_VALPAR) ? "value parameter" :
(df->df_flags & D_VARPAR) ? "variable parameter" :
(df->df_kind == D_VARIABLE) ? "variable" :
(df->df_kind == D_TYPE) ? "type" :
(df->df_kind == D_CONST) ? "constant" :
"procedure",
(df->df_flags & D_VALPAR) ? "value parameter" : (df->df_flags & D_VARPAR) ? "variable parameter" : (df->df_kind == D_VARIABLE) ? "variable" : (df->df_kind == D_TYPE) ? "type" : (df->df_kind == D_CONST) ? "constant" : "procedure",
df->df_idf->id_text, warning);
}
}
static void
UseWarnings(df)
register t_def *df;
UseWarnings(df) register t_def* df;
{
t_node* nd = df->df_scope->sc_end;
if (is_anon_idf(df->df_idf) ||
!(df->df_kind&(D_IMPORTED|D_VARIABLE|D_PROCEDURE|D_CONST|D_TYPE)) ||
(df->df_flags&(D_EXPORTED|D_QEXPORTED))) {
if (is_anon_idf(df->df_idf) || !(df->df_kind & (D_IMPORTED | D_VARIABLE | D_PROCEDURE | D_CONST | D_TYPE)) || (df->df_flags & (D_EXPORTED | D_QEXPORTED)))
{
return;
}
if (df->df_kind & D_IMPORTED) {
if (df->df_kind & D_IMPORTED)
{
register t_def* df1 = df->imp_def;
df1->df_flags |= df->df_flags & (D_USED | D_DEFINED);
if (df->df_kind == D_INUSE) return;
if ( !(df->df_flags & D_IMP_BY_EXP)) {
if (df->df_flags & (D_USED | D_DEFINED)) {
if (df->df_kind == D_INUSE)
return;
if (!(df->df_flags & D_IMP_BY_EXP))
{
if (df->df_flags & (D_USED | D_DEFINED))
{
return;
}
df_warning(nd,
df1,
df1->df_kind == D_VARIABLE ?
"imported but not used/assigned" :
"imported but not used");
df1->df_kind == D_VARIABLE ? "imported but not used/assigned" : "imported but not used");
return;
}
df = df1;
nd = df->df_scope->sc_end;
}
switch(df->df_flags & (D_USED|D_DEFINED|D_VALPAR|D_VARPAR)) {
switch (df->df_flags & (D_USED | D_DEFINED | D_VALPAR | D_VARPAR))
{
case 0:
case D_VARPAR:
df_warning(nd, df, "never used/assigned");
@ -1130,11 +1207,11 @@ UseWarnings(df)
}
}
WalkDefList(df, proc)
register t_def *df;
WalkDefList(df, proc) register t_def* df;
int (*proc)();
{
for (; df; df = df->df_nextinscope) {
for (; df; df = df->df_nextinscope)
{
(*proc)(df);
}
}
@ -1144,7 +1221,8 @@ static int
stabdef(df)
t_def* df;
{
switch(df->df_kind) {
switch (df->df_kind)
{
case D_CONST:
case D_VARIABLE:
stb_string(df, df->df_kind);