code for these parts.
*/
-#include <stdlib.h>
-#include <string.h>
+#include <stdlib.h>
+#include <string.h>
#include "parameters.h"
-#include "debug.h"
-
-#include <em_arith.h>
-#include <em_label.h>
-#include <em_reg.h>
-#include <em_code.h>
-#include <m2_traps.h>
-#include <stb.h>
-
-#include "LLlex.h"
-#include "def.h"
-#include "type.h"
-#include "scope.h"
-#include "main.h"
-#include "node.h"
-#include "Lpars.h"
-#include "desig.h"
-#include "f_info.h"
-#include "idf.h"
-#include "chk_expr.h"
-#include "walk.h"
-#include "misc.h"
-#include "warning.h"
-
-extern arith NewPtr();
-extern arith NewInt();
-extern arith TmpSpace();
-
-extern int proclevel;
-extern int gdb_flag;
-
-label text_label;
-label data_label = 1;
-struct withdesig *WithDesigs;
-t_node *Modules;
-
-static t_type *func_type;
-static t_node *priority;
-static int oldlineno;
-
-static int RegisterMessage();
-static int WalkDef();
+#include "debug.h"
+
+#include <em_arith.h>
+#include <em_label.h>
+#include <em_reg.h>
+#include <em_code.h>
+#include <m2_traps.h>
+#include <assert.h>
+#include <alloc.h>
+#include <stb.h>
+
+#include "LLlex.h"
+#include "def.h"
+#include "type.h"
+#include "scope.h"
+#include "main.h"
+#include "node.h"
+#include "Lpars.h"
+#include "desig.h"
+#include "f_info.h"
+#include "idf.h"
+#include "chk_expr.h"
+#include "walk.h"
+#include "misc.h"
+#include "warning.h"
+
+extern arith NewPtr();
+extern arith NewInt();
+extern arith TmpSpace();
+
+extern int proclevel;
+extern int gdb_flag;
+
+label text_label;
+label data_label = 1;
+struct withdesig* WithDesigs;
+t_node* Modules;
+
+static t_type* func_type;
+static t_node* priority;
+static int oldlineno;
+
+static int RegisterMessage();
+static int WalkDef();
#ifdef DBSYMTAB
-static int stabdef();
+static int stabdef();
#endif
-static int MkCalls();
-static void UseWarnings();
+static int MkCalls();
+static void UseWarnings();
-#define NO_EXIT_LABEL ((label) 0)
-#define RETURN_LABEL ((label) 1)
+#define NO_EXIT_LABEL ((label)0)
+#define RETURN_LABEL ((label)1)
-#define REACH_FLAG 1
-#define EXIT_FLAG 2
+#define REACH_FLAG 1
+#define EXIT_FLAG 2
void DoAssign();
int
-LblWalkNode(lbl, nd, exit, reach)
- label lbl, exit;
- t_node *nd;
+ LblWalkNode(lbl, nd, exit, reach)
+ label lbl,
+ exit;
+t_node* nd;
{
/* Generate code for node "nd", after generating instruction
label "lbl". "exit" is the exit label for the closest
/* 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);
+ CAL("stackprio", (int)word_size);
C_lfr(word_size);
C_stl(tmpprio);
}
STATIC
EndPriority()
{
- if (priority) {
+ if (priority)
+ {
C_lol(tmpprio);
- CAL("unstackprio", (int) word_size);
+ CAL("unstackprio", (int)word_size);
FreeInt(tmpprio);
}
}
def_ilb(l)
- label l;
+ label l;
{
/* Instruction label definition. Forget about line number.
*/
oldlineno = 0;
}
-DoLineno(nd)
- register t_node *nd;
+DoLineno(nd) register t_node* nd;
{
/* Generate line number information, if necessary.
*/
- if ((! options['L']
+ if ((!options['L']
#ifdef DBSYMTAB
- || options['g']
+ || 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']) {
- static int ms_lineno;
+ 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);
+ C_ms_std((char*)0, N_SLINE, ms_lineno);
}
}
#endif /* DBSYMTAB */
procedure entry, and after generating a call to
another procedure.
*/
- static label filename_label = 0;
+ static label filename_label = 0;
- oldlineno = 0; /* always invalidate remembered line number */
- if (needed && ! options['L']) {
+ oldlineno = 0; /* always invalidate remembered line number */
+ 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));
+ C_df_dlb((label)1);
+ C_rom_scon(FileName, (arith)(strlen(FileName) + 1));
}
- C_fil_dlb((label) 1, (arith) 0);
+ C_fil_dlb((label)1, (arith)0);
}
}
-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.
This code is collected in an initialization routine.
*/
- register t_scope *sc;
- t_scopelist *savevis = CurrVis;
+ register t_scope* sc;
+ t_scopelist* savevis = CurrVis;
CurrVis = module->mod_vis;
priority = module->mod_priority;
First call initialization routines for modules defined within
this module.
*/
- sc->sc_off = 0; /* no locals (yet) */
- text_label = 1; /* label at end of initialization routine */
- TmpOpen(sc); /* Initialize for temporaries */
+ sc->sc_off = 0; /* no locals (yet) */
+ text_label = 1; /* label at end of initialization routine */
+ 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,
- (arith) 0);
+ N_MAIN,
+ 0,
+ (arith)0);
}
stb_string(module, D_END);
}
#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;
+ register t_node* nd = Modules;
- if (state == IMPLEMENTATION) {
+ if (state == IMPLEMENTATION)
+ {
/* We don't actually prevent recursive calls,
but do nothing if called recursively
*/
C_df_dlb(++data_label);
- C_con_cst((arith) 0);
+ C_con_cst((arith)0);
/* if this one is set to non-zero, the initialization
was already done.
*/
- C_loe_dlb(data_label, (arith) 0);
+ C_loe_dlb(data_label, (arith)0);
C_zne(RETURN_LABEL);
- C_ine_dlb(data_label, (arith) 0);
+ 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);
WalkDefList(sc->sc_def, MkCalls);
proclevel++;
#ifdef DBSYMTAB
- if (options['g']) {
- C_ms_std((char *) 0, N_LBRAC, gdb_flag ? 0 : proclevel);
+ if (options['g'])
+ {
+ C_ms_std((char*)0, N_LBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
WalkNode(module->mod_body, NO_EXIT_LABEL, REACH_FLAG);
DO_DEBUG(options['X'], PrNode(module->mod_body, 0));
def_ilb(RETURN_LABEL);
EndPriority();
- C_ret((arith) 0);
+ C_ret((arith)0);
#ifdef DBSYMTAB
- if (options['g']) {
- C_ms_std((char *) 0, N_RBRAC, gdb_flag ? 0 : proclevel);
+ if (options['g'])
+ {
+ C_ms_std((char*)0, N_RBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
C_end(-sc->sc_off);
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.
*/
- t_scopelist *savevis = CurrVis;
- register t_type *tp;
- register t_param *param;
- register t_scope *procscope = procedure->prc_vis->sc_scope;
- label too_big = 0; /* returnsize larger than returnarea */
- arith StackAdjustment = 0; /* space for conformant arrays */
- arith retsav = 0; /* temporary space for return value */
+ t_scopelist* savevis = CurrVis;
+ register t_type* tp;
+ register t_param* param;
+ register t_scope* procscope = procedure->prc_vis->sc_scope;
+ label too_big = 0; /* returnsize larger than returnarea */
+ arith StackAdjustment = 0; /* space for conformant arrays */
+ arith retsav = 0; /* temporary space for return value */
arith func_res_size = 0;
#ifdef USE_INSERT
int partno = C_getid();
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,
*/
TmpOpen(procscope);
#ifdef USE_INSERT
- C_insertpart(partno2); /* procedure header */
+ C_insertpart(partno2); /* procedure header */
#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);
- C_ms_std((char *) 0, N_LBRAC, gdb_flag ? 0 : proclevel);
+ C_ms_std((char*)0, N_LBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
C_ms_par(procedure->df_type->prc_nbpar
#ifdef BIG_RESULT_ON_STACK
- + (too_big ? func_res_size : 0)
+ + (too_big ? func_res_size : 0)
#endif
- );
+ );
#endif
/* generate code for filename only when the procedure can be
exported, either directly or by taking the address.
DoFilename(procscope->sc_level == 1);
DoPriority();
- text_label = 1; /* label at end of procedure */
+ text_label = 1; /* label at end of 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
*/
- retsav= TmpSpace(func_res_size, 1);
+ retsav = TmpSpace(func_res_size, 1);
}
StackAdjustment = NewPtr();
- C_lor((arith) 1);
+ C_lor((arith)1);
STL(StackAdjustment, pointer_size);
}
}
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",
- procedure->df_idf->id_text);
+ W_ORDINARY,
+ "function procedure \"%s\" does not always return a value",
+ procedure->df_idf->id_text);
c_loc(M2_NORESULT);
C_trp();
C_asp(-func_res_size);
*/
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);
CAL("new_stackptr", (int)pointer_size);
C_lfr(pointer_size);
C_ass(pointer_size);
- /* adjusted stack pointer */
+ /* adjusted stack pointer */
LOL(param->par_def->var_off, pointer_size);
- /* push source address */
+ /* push source address */
CAL("copy_array", (int)pointer_size);
- /* copy */
+ /* copy */
}
}
#ifdef USE_INSERT
c_bra(cd_body);
#endif
DO_DEBUG(options['X'], PrNode(procedure->prc_body, 0));
- def_ilb(RETURN_LABEL); /* label at end */
- if (too_big) {
- /* Fill the data area reserved for the function result
+ def_ilb(RETURN_LABEL); /* label at end */
+ if (too_big)
+ {
+/* Fill the data area reserved for the function result
with the result
*/
#ifdef BIG_RESULT_ON_STACK
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);
- C_str((arith) 1);
+ C_str((arith)1);
}
#ifdef BIG_RESULT_ON_STACK
func_res_size = 0;
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) {
+ C_str((arith)1);
+ if (func_type)
+ {
LOL(retsav, func_res_size);
}
}
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);
- C_ms_std((char *) 0, N_LBRAC, gdb_flag ? 0 : proclevel);
+ C_ms_std((char*)0, N_LBRAC, gdb_flag ? 0 : proclevel);
}
#endif /* DBSYMTAB */
C_ms_par(procedure->df_type->prc_nbpar
#ifdef BIG_RESULT_ON_STACK
- + (too_big ? func_res_size : 0)
+ + (too_big ? func_res_size : 0)
#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']) {
- C_ms_std((char *) 0, N_RBRAC, gdb_flag ? 0 : proclevel);
+ 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");
+ "maximum local byte count exceeded");
}
TmpClose();
CurrVis = savevis;
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) {
- case D_MODULE:
- WalkModule(df);
- break;
- case D_PROCEDURE:
- WalkProcedure(df);
- break;
- case D_VARIABLE:
- if (!proclevel && !(df->df_flags & D_ADDRGIVEN)) {
- C_df_dnam(df->var_name);
- C_bss_cst(
- WA(df->df_type->tp_size),
- (arith) 0, 0);
- }
- break;
- default:
- /* nothing */
- ;
+ switch (df->df_kind)
+ {
+ case D_MODULE:
+ WalkModule(df);
+ break;
+ case D_PROCEDURE:
+ WalkProcedure(df);
+ break;
+ case D_VARIABLE:
+ if (!proclevel && !(df->df_flags & D_ADDRGIVEN))
+ {
+ C_df_dnam(df->var_name);
+ C_bss_cst(
+ WA(df->df_type->tp_size),
+ (arith)0, 0);
+ }
+ break;
+ default:
+ /* nothing */
+ ;
}
}
-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) {
- C_lxl((arith) 0);
+ 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;
- label exit_label;
+WalkLink(nd, exit_label, end_reached) register t_node* nd;
+label exit_label;
{
/* Walk node "nd", which is a link.
"exit_label" is set to a label number when inside a LOOP.
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;
}
}
STATIC
-ForLoopVarExpr(nd)
- register t_node *nd;
+ForLoopVarExpr(nd) register t_node* nd;
{
- register t_type *tp = nd->nd_type;
+ register t_type* tp = nd->nd_type;
CodePExpr(nd);
CodeCoercion(tp, BaseType(tp));
}
int
-WalkStat(nd, exit_label, end_reached)
- register t_node *nd;
- label exit_label;
+ WalkStat(nd, exit_label, end_reached) register t_node* nd;
+label exit_label;
{
/* Walk through a statement, generating code for it.
*/
- register t_node *left = nd->nd_LEFT;
- register t_node *right = nd->nd_RIGHT;
+ register t_node* left = nd->nd_LEFT;
+ register t_node* right = nd->nd_RIGHT;
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 '(': {
- t_node *nd1 = nd;
- if (ChkCall(&nd1)) {
- assert(nd == nd1);
- if (nd->nd_type != 0) {
- node_error(nd, "procedure call expected instead of function call");
- break;
+ switch (nd->nd_symb)
+ {
+ case '(':
+ {
+ t_node* nd1 = nd;
+ if (ChkCall(&nd1))
+ {
+ assert(nd == nd1);
+ if (nd->nd_type != 0)
+ {
+ node_error(nd, "procedure call expected instead of function call");
+ break;
+ }
+ CodeCall(nd);
}
- CodeCall(nd);
- }
}
break;
- case BECOMES:
- DoAssign(nd);
- break;
+ case BECOMES:
+ DoAssign(nd);
+ break;
- case IF:
- { label l1 = ++text_label, l3 = ++text_label;
+ case IF:
+ {
+ 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;
}
- case CASE:
- end_reached = CaseCode(nd, exit_label, end_reached);
- break;
+ case CASE:
+ end_reached = CaseCode(nd, exit_label, end_reached);
+ break;
- case WHILE:
- { label loop = ++text_label,
- exit = ++text_label,
- dummy = ++text_label;
+ case WHILE:
+ {
+ label loop = ++text_label,
+ exit = ++text_label,
+ dummy = ++text_label;
c_bra(dummy);
end_reached |= LblWalkNode(loop, right, exit_label, end_reached);
break;
}
- case REPEAT:
- { label loop = ++text_label, exit = ++text_label;
+ case REPEAT:
+ {
+ label loop = ++text_label, exit = ++text_label;
end_reached = LblWalkNode(loop, left, exit_label, end_reached);
ExpectBool(&(nd->nd_RIGHT), exit, loop);
break;
}
- case LOOP:
- { label loop = ++text_label, exit = ++text_label;
+ case LOOP:
+ {
+ 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;
}
- case FOR:
+ case FOR:
{
arith tmp = NewInt();
arith tmp2 = NewInt();
label l2 = ++text_label;
int uns = 0;
arith stepsize;
- t_type *bstp;
- t_node *loopid;
+ t_type* bstp;
+ t_node* loopid;
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");
+ 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);
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);
+ 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);
}
loopid->nd_def->df_flags &= ~D_FORLOOP;
FreeInt(tmp2);
- if (stepsize) {
+ if (stepsize)
+ {
C_lol(tmp);
C_zeq(l2);
C_lol(tmp);
CodeDStore(loopid);
}
}
- else {
+ else
+ {
end_reached |= WalkNode(right->nd_RIGHT, exit_label, end_reached);
loopid->nd_def->df_flags &= ~D_FORLOOP;
}
}
break;
- case WITH:
+ case WITH:
{
t_scopelist link;
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;
}
CurrVis = link.sc_next;
WithDesigs = wds.w_next;
FreePtr(ds.dsg_offset);
- ChkDesig(&(nd->nd_LEFT), wds.w_flags & (D_USED|D_DEFINED));
+ ChkDesig(&(nd->nd_LEFT), wds.w_flags & (D_USED | D_DEFINED));
break;
}
- case EXIT:
- assert(exit_label != 0);
+ case EXIT:
+ assert(exit_label != 0);
- if (end_reached & REACH_FLAG) end_reached = EXIT_FLAG;
- c_bra(exit_label);
- break;
+ 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;
- /* The type of the return-expression must be
+ case RETURN:
+ end_reached &= ~REACH_FLAG;
+ 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")) {
- break;
- }
- right = nd->nd_RIGHT;
- if (right->nd_type->tp_fund == T_STRING) {
- CodePString(right, func_type);
+ if (!ChkAssCompat(&(nd->nd_RIGHT), func_type, "RETURN"))
+ {
+ break;
+ }
+ right = nd->nd_RIGHT;
+ if (right->nd_type->tp_fund == T_STRING)
+ {
+ CodePString(right, func_type);
+ }
+ else
+ CodePExpr(right);
}
- else CodePExpr(right);
- }
- c_bra(RETURN_LABEL);
- break;
+ c_bra(RETURN_LABEL);
+ break;
- default:
- crash("(WalkStat)");
+ default:
+ crash("(WalkStat)");
}
return end_reached;
}
-extern int NodeCrash();
+extern int NodeCrash();
int (*WalkTable[])() = {
NodeCrash,
extern t_desig null_desig;
-ExpectBool(pnd, true_label, false_label)
- register t_node **pnd;
- label true_label, false_label;
+ExpectBool(pnd, true_label, false_label) register t_node** pnd;
+label true_label, false_label;
{
/* "pnd" must indicate a boolean expression. Check this and
generate code to evaluate the expression.
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");
}
- CodeExpr(*pnd, &ds, true_label, false_label);
+ CodeExpr(*pnd, &ds, true_label, false_label);
}
}
int
-WalkDesignator(pnd, ds, flags)
- t_node **pnd;
- t_desig *ds;
+ WalkDesignator(pnd, ds, flags)
+ t_node** pnd;
+t_desig* ds;
{
/* 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);
}
DoForInit(nd)
- t_node *nd;
+ t_node* nd;
{
- register t_node *right = nd->nd_RIGHT;
- register t_def *df;
- t_type *base_tp;
+ register t_node* right = nd->nd_RIGHT;
+ register t_def* df;
+ t_type* base_tp;
t_type *tpl, *tpr;
int r;
- r = ChkVariable(&(nd->nd_LEFT), D_USED|D_DEFINED);
+ 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");
+ "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) {
- register t_scopelist *sc = CurrVis;
+ 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");
+ "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;
}
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")) {
- return 1;
- }
- if (!TstCompat(df->df_type, tpl) ||
- !TstCompat(df->df_type, tpr)) {
-node_warning(nd, W_OLDFASHIONED, "compatibility required in FOR statement");
- }
- } else
+ 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))
+ {
+ node_warning(nd, W_OLDFASHIONED, "compatibility required in FOR statement");
+ }
+ }
+ 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;
}
}
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:
DAMN THE BOOK!
*/
t_desig dsr;
- register t_type *tp;
+ 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;
-#define StackNeededFor(ds) ((ds).dsg_kind == DSG_PLOADED \
- || (ds).dsg_kind == DSG_INDEXED)
+#define StackNeededFor(ds) ((ds).dsg_kind == DSG_PLOADED \
+ || (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;
+ 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);
+ 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,
- 0);
+ tp->tp_size,
+ tp->tp_fund == T_REAL ? reg_float : reg_any,
+ 0);
}
}
}
}
static void
-df_warning(nd, df, warning)
- t_node *nd;
- t_def *df;
- char *warning;
+ df_warning(nd, df, warning)
+ t_node* nd;
+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_idf->id_text, warning);
+ 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_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;
+ 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) {
- register t_def *df1 = df->imp_def;
+ 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)) {
+ 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))
+ {
return;
}
df_warning(nd,
- df1,
- df1->df_kind == D_VARIABLE ?
- "imported but not used/assigned" :
- "imported but not used");
+ df1,
+ 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)) {
- case 0:
- case D_VARPAR:
- df_warning(nd, df,"never used/assigned");
- break;
- case D_USED:
- df_warning(nd, df,"never assigned");
- break;
- case D_VALPAR:
- case D_DEFINED:
- case D_DEFINED|D_VALPAR:
- df_warning(nd, df,"never used");
- break;
+ switch (df->df_flags & (D_USED | D_DEFINED | D_VALPAR | D_VARPAR))
+ {
+ case 0:
+ case D_VARPAR:
+ df_warning(nd, df, "never used/assigned");
+ break;
+ case D_USED:
+ df_warning(nd, df, "never assigned");
+ break;
+ case D_VALPAR:
+ case D_DEFINED:
+ case D_DEFINED | D_VALPAR:
+ df_warning(nd, df, "never used");
+ break;
}
}
-WalkDefList(df, proc)
- register t_def *df;
- int (*proc)();
+WalkDefList(df, proc) register t_def* df;
+int (*proc)();
{
- for (; df; df = df->df_nextinscope) {
+ for (; df; df = df->df_nextinscope)
+ {
(*proc)(df);
}
}
#ifdef DBSYMTAB
static int
-stabdef(df)
- t_def *df;
+ stabdef(df)
+ t_def* df;
{
- switch(df->df_kind) {
- case D_CONST:
- case D_VARIABLE:
- stb_string(df, df->df_kind);
- break;
+ switch (df->df_kind)
+ {
+ case D_CONST:
+ case D_VARIABLE:
+ stb_string(df, df->df_kind);
+ break;
}
}
#endif
public / ack.git / commitdiff