Return to 1750a.c CVS log

Up to [GCC 2.x] / gcc / config / 1750a

Annotation of gcc/config/1750a/1750a.c, revision 1.1

1.1     ! root        1: /* Subroutines for insn-output.c for MIL-STD-1750.
        !             2:    Copyright (C) 1994 Free Software Foundation, Inc.
        !             3:    Contributed by O.M.Kellogg, DASA ([email protected]).
        !             4: 
        !             5: This file is part of GNU CC.
        !             6: 
        !             7: GNU CC is free software; you can redistribute it and/or modify
        !             8: it under the terms of the GNU General Public License as published by
        !             9: the Free Software Foundation; either version 1, or (at your option)
        !            10: any later version.
        !            11: 
        !            12: GNU CC is distributed in the hope that it will be useful,
        !            13: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            15: GNU General Public License for more details.
        !            16: 
        !            17: You should have received a copy of the GNU General Public License
        !            18: along with GNU CC; see the file COPYING.  If not, write to
        !            19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            20: 
        !            21: #ifndef FILE
        !            22: #include <stdio.h>
        !            23: #endif
        !            24: 
        !            25: #define __datalbl
        !            26: #include "config.h"
        !            27: #include "rtl.h"
        !            28: #include "tree.h"
        !            29: #include "expr.h"
        !            30: #define HAVE_cc0
        !            31: #include "conditions.h"
        !            32: #include "real.h"
        !            33: 
        !            34: struct datalabel_array datalbl[DATALBL_ARRSIZ];
        !            35: int datalbl_ndx = -1;
        !            36: struct jumplabel_array jmplbl[JMPLBL_ARRSIZ];
        !            37: int jmplbl_ndx = -1;
        !            38: int label_pending = 0, program_counter = 0;
        !            39: enum section current_section = Normal;
        !            40: char *sectname[4] =
        !            41: {"Normal", "Init", "Konst", "Static"};
        !            42: 
        !            43: int
        !            44: notice_update_cc (exp)
        !            45:      rtx exp;
        !            46: {
        !            47:   if (GET_CODE (exp) == SET)
        !            48:     {
        !            49:       enum rtx_code src_code = GET_CODE (SET_SRC (exp));
        !            50:       /* Jumps do not alter the cc's.  */
        !            51:       if (SET_DEST (exp) == pc_rtx)
        !            52:        return;
        !            53:       /* Moving register into memory doesn't alter the cc's.
        !            54:         It may invalidate the RTX's which we remember the cc's came from.  */
        !            55:       if (GET_CODE (SET_DEST (exp)) == MEM)
        !            56:        {
        !            57:          if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM)
        !            58:            cc_status.value1 = 0;
        !            59:          if (cc_status.value2 && GET_CODE (cc_status.value2) == MEM)
        !            60:            cc_status.value2 = 0;
        !            61:          return;
        !            62:        }
        !            63:       /* Function calls clobber the cc's.  */
        !            64:       else if (src_code == CALL)
        !            65:        {
        !            66:          CC_STATUS_INIT;
        !            67:          return;
        !            68:        }
        !            69:       /* Emulated longword bit-ops leave cc's incorrect */
        !            70:       else if (GET_MODE (SET_DEST (exp)) == HImode ?
        !            71:               src_code == AND || src_code == IOR ||
        !            72:               src_code == XOR || src_code == NOT : 0)
        !            73:        {
        !            74:          CC_STATUS_INIT;
        !            75:          return;
        !            76:        }
        !            77:       /* Tests and compares set the cc's in predictable ways.  */
        !            78:       else if (SET_DEST (exp) == cc0_rtx)
        !            79:        {
        !            80:          CC_STATUS_INIT;
        !            81:          cc_status.value1 = SET_SRC (exp);
        !            82:          return;
        !            83:        }
        !            84:       /* Anything that lands in a reg will set cc_status. */
        !            85:       else if (REG_P (SET_DEST (exp)))
        !            86:        {
        !            87:          cc_status.flags = CC_NO_OVERFLOW;
        !            88:          cc_status.value1 = SET_SRC (exp);
        !            89:          cc_status.value2 = SET_DEST (exp);
        !            90:          return;
        !            91:        }
        !            92:       else
        !            93:        {
        !            94:          CC_STATUS_INIT;
        !            95:        }
        !            96:     }
        !            97:   else if (GET_CODE (exp) == PARALLEL
        !            98:           && GET_CODE (XVECEXP (exp, 0, 0)) == SET)
        !            99:     {
        !           100:       if (SET_DEST (XVECEXP (exp, 0, 0)) == pc_rtx)
        !           101:        return;
        !           102:       if (SET_DEST (XVECEXP (exp, 0, 0)) == cc0_rtx)
        !           103:        {
        !           104:          CC_STATUS_INIT;
        !           105:          cc_status.value1 = SET_SRC (XVECEXP (exp, 0, 0));
        !           106:          return;
        !           107:        }
        !           108:       CC_STATUS_INIT;
        !           109:     }
        !           110:   else
        !           111:     {
        !           112:       CC_STATUS_INIT;
        !           113:     }
        !           114: }
        !           115: 
        !           116: 
        !           117: rtx
        !           118: function_arg (cum, mode, type, named)
        !           119:      int cum;
        !           120:      enum machine_mode mode;
        !           121:      tree type;
        !           122:      int named;
        !           123: {
        !           124:   int size;
        !           125:   rtx result;
        !           126: 
        !           127:   if (MUST_PASS_IN_STACK (mode, type))
        !           128:     return (rtx) 0;
        !           129:   if (mode == BLKmode)
        !           130:     size = int_size_in_bytes (type);
        !           131:   else
        !           132:     size = GET_MODE_SIZE (mode);
        !           133:   if (cum + size < 12)
        !           134:     return gen_rtx (REG, mode, cum);
        !           135:   else
        !           136:     return (rtx) 0;
        !           137: }
        !           138: 
        !           139: 
        !           140: #ifndef STRDUP
        !           141: char *
        !           142: strdup (str)
        !           143:      char *str;
        !           144: {
        !           145:   char *p;
        !           146:   if (str == NULL)
        !           147:     return NULL;
        !           148:   if ((p = (char *) malloc (strlen (str) + 1)) == NULL)
        !           149:     {
        !           150:       fprintf (stderr, "dynamic memory exhausted");
        !           151:       abort ();
        !           152:     }
        !           153:   return strcpy (p, str);
        !           154: }
        !           155: 
        !           156: #endif
        !           157: 
        !           158: 
        !           159: double
        !           160: get_double (x)
        !           161:      rtx x;
        !           162: {
        !           163:   union
        !           164:     {
        !           165:       double d;
        !           166:       long i[2];
        !           167:     }
        !           168:   du;
        !           169: 
        !           170:   du.i[0] = CONST_DOUBLE_LOW (x);
        !           171:   du.i[1] = CONST_DOUBLE_HIGH (x);
        !           172:   return du.d;
        !           173: }
        !           174: 
        !           175: char *
        !           176: float_label (code, value)
        !           177:      char code;
        !           178:      double value;
        !           179: {
        !           180:   int i = 1;
        !           181:   static char label[32];
        !           182:   char *p;
        !           183: 
        !           184:   label[0] = code;
        !           185:   p = label + 1;
        !           186:   sprintf (p, "%lf", value);
        !           187:   while (*p)
        !           188:     {
        !           189:       *p = (*p == '+') ? 'p' :
        !           190:        (*p == '-') ? 'm' : *p;
        !           191:       p++;
        !           192:     }
        !           193:   return strdup (label);
        !           194: }
        !           195: 
        !           196: 
        !           197: char *
        !           198: movcnt_regno_adjust (rtx * op)
        !           199: {
        !           200:   static char outstr[40];
        !           201:   int cntreg = REGNO (op[2]), cntreg_1750 = REGNO (op[0]) + 1;
        !           202:   int dstreg = REGNO (op[0]), srcreg = REGNO (op[1]);
        !           203: 
        !           204:   if (cntreg == cntreg_1750)
        !           205:     sprintf (outstr, "mov r%%0,r%%1");
        !           206:   else if (dstreg + 1 == srcreg && srcreg == cntreg + 2)
        !           207:     sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", cntreg, dstreg);
        !           208:   else if (dstreg + 1 == srcreg && srcreg < cntreg)
        !           209:     sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", srcreg, cntreg);
        !           210:   else if (srcreg + 1 == cntreg && dstreg > cntreg)
        !           211:     sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", srcreg, dstreg);
        !           212:   else
        !           213:     sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,%%1\n\txwr r%d,r%d",
        !           214:             cntreg, cntreg_1750, cntreg_1750, cntreg);
        !           215:   return outstr;
        !           216: }
        !           217: 
        !           218: char *
        !           219: mod_regno_adjust (char *instr, rtx * op)
        !           220: {
        !           221:   static char outstr[40];
        !           222:   char *r = (!strncmp (instr, "dvr", 3) ? "r" : "");
        !           223:   int modregno_gcc = REGNO (op[3]), modregno_1750 = REGNO (op[0]) + 1;
        !           224: 
        !           225:   if (modregno_gcc == modregno_1750)
        !           226:     sprintf (outstr, "%s r%%0,%s%%2", instr, r);
        !           227:   else
        !           228:     sprintf (outstr, "lr r%d,r%d\n\t%s r%%0,%s%%2\n\txwr r%d,r%d",
        !           229:        modregno_gcc, modregno_1750, instr, r, modregno_1750, modregno_gcc);
        !           230:   return outstr;
        !           231: }
        !           232: 
        !           233: 
        !           234: /* Auxiliary to `nonindirect_operand':
        !           235:    Check if op is a valid memory operand for 1750A arith./logic (non-move)
        !           236:    instructions. */
        !           237: int
        !           238: memop_valid (register rtx op)
        !           239: {
        !           240:   if (GET_MODE (op) != Pmode && GET_MODE (op) != VOIDmode)
        !           241:     return 0;
        !           242:   switch (GET_CODE (op))
        !           243:     {
        !           244:     case MEM:
        !           245:     case MINUS:
        !           246:     case MULT:
        !           247:     case DIV:
        !           248:       return 0;
        !           249:     case PLUS:
        !           250:       if (!memop_valid (XEXP (op, 0)))
        !           251:        return 0;
        !           252:       return memop_valid (XEXP (op, 1));
        !           253:     case REG:
        !           254:       if (REGNO (op) > 0)
        !           255:        return 1;
        !           256:       return 0;
        !           257:     case CONST:
        !           258:     case CONST_INT:
        !           259:     case SYMBOL_REF:
        !           260:     case SUBREG:
        !           261:       return 1;
        !           262:     default:
        !           263:       printf ("memop_valid: code=%d\n", (int) GET_CODE (op));
        !           264:       return 1;
        !           265:     }
        !           266: }
        !           267: 
        !           268: /* extra predicate for recog: */
        !           269: int
        !           270: nonindirect_operand (register rtx op, enum machine_mode mode)
        !           271: {
        !           272:   int retval;
        !           273: 
        !           274:   switch (GET_CODE (op))
        !           275:     {
        !           276:     case MEM:
        !           277:       retval = memop_valid (XEXP (op, 0));
        !           278:       return retval;
        !           279:     case REG:
        !           280:       return 1;
        !           281:     default:
        !           282:       if (!CONSTANT_P (op))
        !           283:        return 0;
        !           284:     }
        !           285:   return 1;
        !           286: }
        !           287: 
        !           288: /* predicate for the STC instruction: */
        !           289: int
        !           290: small_nonneg_const (register rtx op, enum machine_mode mode)
        !           291: {
        !           292:   if (GET_CODE (op) == CONST_INT && INTVAL (op) >= 0 && INTVAL (op) <= 15)
        !           293:     return 1;
        !           294:   return 0;
        !           295: }
        !           296: 
        !           297: /* Decide whether to output a conditional jump as a "Jump Conditional"
        !           298:    or as a "Branch Conditional": */
        !           299: 
        !           300: int
        !           301: find_jmplbl (int labelnum)
        !           302: {
        !           303:   int i, found = 0;
        !           304: 
        !           305:   for (i = 0; i <= jmplbl_ndx; i++)
        !           306:     if (labelnum == jmplbl[i].num)
        !           307:       {
        !           308:        found = 1;
        !           309:        break;
        !           310:       }
        !           311:   if (found)
        !           312:     return i;
        !           313:   return -1;
        !           314: }
        !           315: 
        !           316: char *
        !           317: branch_or_jump (char *condition, int targetlabel_number)
        !           318: {
        !           319:   static char buf[30];
        !           320:   int index;
        !           321: 
        !           322:   if ((index = find_jmplbl (targetlabel_number)) >= 0)
        !           323:     if (program_counter - jmplbl[index].pc < 128)
        !           324:       {
        !           325:        sprintf (buf, "b%s %%l0", condition);
        !           326:        return buf;
        !           327:       }
        !           328:   sprintf (buf, "jc %s,%%l0", condition);
        !           329:   return buf;
        !           330: }
        !           331: 
        !           332: 
        !           333: 
        !           334: /* The PRINT_OPERAND and PRINT_OPERAND_ADDRESS macros have been
        !           335:    made functions: */
        !           336: 
        !           337: print_operand (file, x, kode)
        !           338:      FILE *file;
        !           339:      rtx x;
        !           340:      enum rtx_code kode;
        !           341: {
        !           342:   switch (GET_CODE (x))
        !           343:     {
        !           344:     case REG:
        !           345:       fprintf (file, "%d", REGNO (x));
        !           346:       break;
        !           347:     case SYMBOL_REF:
        !           348:       fprintf (file, "%s", XSTR (x, 0));
        !           349:       break;
        !           350:     case LABEL_REF:
        !           351:     case CONST:
        !           352:     case MEM:
        !           353:       output_address (XEXP (x, 0));
        !           354:       break;
        !           355:     case CONST_DOUBLE:
        !           356: /*    {
        !           357:        double value = get_double (x);
        !           358:        char fltstr[32];
        !           359:        sprintf (fltstr, "%lf", value);
        !           360: 
        !           361:        if (kode == 'D' || kode == 'E')
        !           362:          {
        !           363:            int i, found = 0;
        !           364:            for (i = 0; i <= datalbl_ndx; i++)
        !           365:              if (strcmp (fltstr, datalbl[i].value) == 0)
        !           366:                {
        !           367:                  found = 1;
        !           368:                  break;
        !           369:                }
        !           370:            if (!found)
        !           371:              {
        !           372:                strcpy (datalbl[i = ++datalbl_ndx].value, fltstr);
        !           373:                datalbl[i].name = float_label (kode, value);
        !           374:                datalbl[i].size = (kode == 'E') ? 3 : 2;
        !           375:                check_section (Konst);
        !           376:                fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name,
        !           377:                        (kode == 'E' ? "ef" : "f"), fltstr);
        !           378:                check_section (Normal);
        !           379:              }
        !           380:          }
        !           381:        else if (kode == 'F' || kode == 'G')
        !           382:          {
        !           383:            int i, found = 0;
        !           384:            for (i = 0; i <= datalbl_ndx; i++)
        !           385:              if (strcmp (fltstr, datalbl[i].value) == 0)
        !           386:                {
        !           387:                  found = 1;
        !           388:                  break;
        !           389:                }
        !           390:            if (!found)
        !           391:              {
        !           392:                fprintf (stderr,
        !           393:                   "float value %lfnot found upon label reference\n", value);
        !           394:                strcpy (datalbl[i = ++datalbl_ndx].value, fltstr);
        !           395:                datalbl[i].name = float_label (kode, value);
        !           396:                datalbl[i].size = (kode == 'G') ? 3 : 2;
        !           397:                check_section (Konst);
        !           398:                fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name,
        !           399:                        (kode == 'G' ? "ef" : "f"), fltstr);
        !           400:                check_section (Normal);
        !           401:              }
        !           402:            fprintf (file, "%s ;P_O 'F'", datalbl[i].name);
        !           403:          }
        !           404:        else
        !           405:          fprintf (file, " %s  ;P_O cst_dbl ", fltstr);
        !           406:       }
        !           407:  */
        !           408:       fprintf (file, "%lf", get_double (x));
        !           409:       break;
        !           410:     case CONST_INT:
        !           411:       if (kode == 'J')
        !           412:        fprintf (file, "%d", -INTVAL (x));
        !           413:       else if (INTVAL (x) > 0x7FFF)
        !           414:        fprintf (file, "%d  ; range correction (val>0x7FFF) applied",
        !           415:                 INTVAL (x) - 0x10000);
        !           416:       else
        !           417:        fprintf (file, "%d", INTVAL (x));
        !           418:       break;
        !           419:     case CODE_LABEL:
        !           420:       fprintf (file, "L%d", XINT (x, 3));
        !           421:       break;
        !           422:     case CALL:
        !           423:       fprintf (file, "CALL nargs=%d, func is either '%s' or '%s'",
        !           424:        XEXP (x, 1), XSTR (XEXP (XEXP (x, 0), 1), 0), XSTR (XEXP (x, 0), 1));
        !           425:       break;
        !           426:     case PLUS:
        !           427:       {
        !           428:        rtx op0 = XEXP (x, 0), op1 = XEXP (x, 1);
        !           429:        int op0code = GET_CODE (op0), op1code = GET_CODE (op1);
        !           430:        if (op1code == CONST_INT)
        !           431:          switch (op0code)
        !           432:            {
        !           433:            case REG:
        !           434:              fprintf (file, "%d,r%d  ; p_o_PLUS for REG and CONST",
        !           435:                       INTVAL (op1), REGNO (op0));
        !           436:              break;
        !           437:            case SYMBOL_REF:
        !           438:              fprintf (file, "%d+%s", INTVAL (op1), XSTR (op0, 0));
        !           439:              break;
        !           440:            case MEM:
        !           441:              fprintf (file, "%d,[mem:", INTVAL (op1));
        !           442:              output_address (XEXP (op0, 0));
        !           443:              fprintf (file, "] ;P_O plus");
        !           444:              break;
        !           445:            default:
        !           446:              fprintf (file, "p_o_PLUS UFO, code=%d, with CONST=%d",
        !           447:                       (int) op0code, INTVAL (op1));
        !           448:            }
        !           449:        else if (op1code == SYMBOL_REF && op0code == REG)
        !           450:          fprintf (file, "%s,r%d  ; P_O: (plus reg sym)",
        !           451:                   XSTR (op1, 0), REGNO (op0));
        !           452:        else
        !           453:          fprintf (file, "p_o_+: op0code=%d, op1code=%d", op0code, op1code);
        !           454:       }
        !           455:       break;
        !           456:     default:
        !           457:       fprintf (file, "p_o_UFO code=%d", GET_CODE (x));
        !           458:     }
        !           459: }
        !           460: 
        !           461: print_operand_address (file, addr)
        !           462:      FILE *file;
        !           463:      rtx addr;
        !           464: {
        !           465:   switch (GET_CODE (addr))
        !           466:     {
        !           467:     case REG:
        !           468:       fprintf (file, "0,r%d ; P_O_A", REGNO (addr));
        !           469:       break;
        !           470:     case PLUS:
        !           471:       {
        !           472:        register rtx x = XEXP (addr, 0), y = XEXP (addr, 1);
        !           473:        switch (GET_CODE (x))
        !           474:          {
        !           475:          case REG:
        !           476:            switch (GET_CODE (y))
        !           477:              {
        !           478:              case CONST:
        !           479:                output_address (XEXP (y, 0));
        !           480:                fprintf (file, ",r%d ;P_O_A reg + const expr", REGNO (x));
        !           481:                break;
        !           482:              case CONST_INT:
        !           483:                fprintf (file, "%d,r%d", INTVAL (y), REGNO (x));
        !           484:                break;
        !           485:              case SYMBOL_REF:
        !           486:                fprintf (file, "%s,r%d  ; P_O_A reg + sym",
        !           487:                         XSTR (y, 0), REGNO (x));
        !           488:                break;
        !           489:              default:
        !           490:                fprintf (file, "[P_O_A reg%d+UFO code=%d]",
        !           491:                         REGNO (x), GET_CODE (y));
        !           492:              }
        !           493:            break;
        !           494:          case LABEL_REF:
        !           495:          case SYMBOL_REF:
        !           496:            switch (GET_CODE (y))
        !           497:              {
        !           498:              case CONST_INT:
        !           499:                fprintf (file, "%d+%s", INTVAL (y), XSTR (x, 0));
        !           500:                break;
        !           501:              case REG:
        !           502:                fprintf (file, "%s,r%d ;P_O_A sym + reg",
        !           503:                         XSTR (x, 0), REGNO (y));
        !           504:                break;
        !           505:              default:
        !           506:                fprintf (file, "P_O_A sym/lab+UFO[sym=%s,code(y)=%d]",
        !           507:                         XSTR (x, 0), GET_CODE (y));
        !           508:              }
        !           509:            break;
        !           510:          case CONST:
        !           511:            output_address (XEXP (x, 0));
        !           512:            if (GET_CODE (y) == REG)
        !           513:              fprintf (file, ",r%d ;P_O_A const + reg", REGNO (x));
        !           514:            else
        !           515:              fprintf (file, "P_O_A const+UFO code(y)=%d]", GET_CODE (y));
        !           516:            break;
        !           517:          case MEM:
        !           518:            output_address (y);
        !           519:            fprintf (file, ",[mem:");
        !           520:            output_address (XEXP (x, 0));
        !           521:            fprintf (file, "] ;P_O_A plus");
        !           522:            break;
        !           523:          default:
        !           524:            fprintf (file, "P_O_A plus op1_UFO[code1=%d,code2=%d]",
        !           525:                     GET_CODE (x), GET_CODE (y));
        !           526:          }
        !           527:       }
        !           528:       break;
        !           529:     case CONST_INT:
        !           530:       if (INTVAL (addr) < 0x10000 && INTVAL (addr) >= -0x10000)
        !           531:        fprintf (file, "%d ; p_o_a const addr?!", INTVAL (addr));
        !           532:       else
        !           533:        {
        !           534:          fprintf (file, "[p_o_a=ILLEGAL_CONST]");
        !           535:          output_addr_const (file, addr);
        !           536:        }
        !           537:       break;
        !           538:     case LABEL_REF:
        !           539:     case SYMBOL_REF:
        !           540:       fprintf (file, "%s", XSTR (addr, 0));
        !           541:       break;
        !           542:     case MEM:
        !           543:       fprintf (file, "[memUFO:");
        !           544:       output_address (XEXP (addr, 0));
        !           545:       fprintf (file, "]");
        !           546:       break;
        !           547:     case CONST:
        !           548:       output_address (XEXP (addr, 0));
        !           549:       fprintf (file, " ;P_O_A const");
        !           550:       break;
        !           551:     default:
        !           552:       fprintf (file, " p_o_a UFO, code=%d val=0x%x",
        !           553:               (int) GET_CODE (addr), INTVAL (addr));
        !           554:       break;
        !           555:     }
        !           556: }
        !           557: 
        !           558: 
        !           559: /*
        !           560: ASM_FILE_END(file)
        !           561:   FILE *file;
        !           562: {
        !           563:       if (datalbl_ndx >= 0) {
        !           564:          int i, cum_size=0;
        !           565:          fprintf(file,"\n\tstatic\ninit_srel\n");
        !           566:          for (i = 0; i <= datalbl_ndx; i++) {
        !           567:           if (datalbl[i].name == NULL) 
        !           568:           {
        !           569:             fprintf (stderr, "asm_file_end intern err (datalbl)\n");
        !           570:             exit (0);
        !           571:           }
        !           572:            fprintf(file,"%s\t block %d\n",
        !           573:                  datalbl[i].name,datalbl[i].size);
        !           574:            cum_size += datalbl[i].size;
        !           575:         }
        !           576:          fprintf(file,"\n\tinit\n");
        !           577:          fprintf(file,"\tLIM  R0,init_srel ;dst\n");
        !           578:          fprintf(file,"\tLIM  R1,%d ;cnt\n",cum_size);
        !           579:          fprintf(file,"\tLIM  R2,K%s ;src\n",datalbl[0].name);
        !           580:          fprintf(file,"\tMOV  R0,R2\n");
        !           581:          fprintf(file,"\n\tnormal\n");
        !           582:          datalbl_ndx = -1;
        !           583:          for (i = 0; i < DATALBL_ARRSIZ; i++)
        !           584:             datalbl[i].size = 0;
        !           585:       }        
        !           586:       fprintf(file,"\n\tend\n");
        !           587: }
        !           588:  */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.