From: David Given Date: Sun, 8 Jan 2017 10:23:56 +0000 (+0100) Subject: Run through clang-format. X-Git-Url: https://git.ndcode.org/public/gitweb.cgi?a=commitdiff_plain;h=ee5ef73dfb8808257b365b0d6ab26d9febcd826f;p=ack.git Run through clang-format. --- diff --git a/lang/m2/comp/walk.c b/lang/m2/comp/walk.c index 93cc3308b..b51316802 100644 --- a/lang/m2/comp/walk.c +++ b/lang/m2/comp/walk.c @@ -13,71 +13,72 @@ code for these parts. */ -#include -#include +#include +#include #include "parameters.h" -#include "debug.h" - -#include -#include -#include -#include -#include -#include -#include -#include - -#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 +#include +#include +#include +#include +#include +#include +#include + +#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 @@ -96,10 +97,11 @@ 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); + CAL("stackprio", (int)word_size); C_lfr(word_size); C_stl(tmpprio); } @@ -108,15 +110,16 @@ DoPriority() 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. */ @@ -124,27 +127,29 @@ def_ilb(l) 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 */ @@ -158,30 +163,31 @@ DoFilename(needed) 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; @@ -195,52 +201,58 @@ WalkModule(module) 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); @@ -248,18 +260,20 @@ WalkModule(module) 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); @@ -270,19 +284,18 @@ 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. */ - 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(); @@ -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, @@ -330,22 +345,23 @@ WalkProcedure(procedure) */ 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. @@ -355,27 +371,31 @@ WalkProcedure(procedure) 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); } } @@ -390,12 +410,14 @@ 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", - 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); @@ -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); @@ -450,11 +475,11 @@ WalkProcedure(procedure) 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 @@ -463,9 +488,10 @@ WalkProcedure(procedure) 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 @@ -474,11 +500,12 @@ 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); - C_str((arith) 1); + C_str((arith)1); } #ifdef BIG_RESULT_ON_STACK func_res_size = 0; @@ -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) { + C_str((arith)1); + if (func_type) + { LOL(retsav, func_res_size); } } @@ -507,32 +537,36 @@ 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); - 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; @@ -540,50 +574,48 @@ 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) { - 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. @@ -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,85 +633,93 @@ 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; + 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); @@ -688,8 +729,9 @@ WalkStat(nd, 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); @@ -697,19 +739,22 @@ WalkStat(nd, exit_label, end_reached) 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(); @@ -718,17 +763,19 @@ WalkStat(nd, exit_label, end_reached) 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); @@ -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); + 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; } @@ -802,15 +860,17 @@ WalkStat(nd, exit_label, end_reached) } 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; } @@ -836,44 +896,50 @@ WalkStat(nd, exit_label, end_reached) 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, @@ -893,9 +959,8 @@ int (*WalkTable[])() = { 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. @@ -903,25 +968,27 @@ 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"); } - 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); @@ -929,47 +996,54 @@ WalkDesignator(pnd, ds, flags) } 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; } @@ -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")) { - 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; } @@ -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: @@ -1007,148 +1082,151 @@ DoAssign(nd) 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