home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / nasm20b / nasm_src / worker.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-19  |  7.3 KB  |  309 lines
  1. /* ---------------------------------------------------------------------- */
  2. /*                   Copyright (C) 1991 by Natürlich!                     */
  3. /*                      This file is copyrighted!                         */
  4. /*                Refer to the documentation for details.                 */
  5. /* ---------------------------------------------------------------------- */
  6. #define LINKER 1
  7. #define __BIG_GENERATOR__
  8. #include "defines.h"
  9. #include "nasm.h"
  10. #include <stdio.h>
  11. #include OSBIND
  12. #include "debug.h"
  13. #include NMALLOC_H
  14. #include "object.h"
  15. #include "process.h"
  16. #include "ldebug.h"
  17.  
  18.  
  19. byte huge         *__program, huge *__p, huge *ptohead;
  20. byte              __c;
  21. word              __pc, __x;
  22. lword             __lx;
  23. extern char       header[], *currfile, trc_loss[];
  24. extern imm huge   *hip, huge *cip;
  25. extern seg huge   *h_seg, huge *sp;
  26. extern word       origin;
  27. extern int        relocatable,
  28.                   bootable,
  29.                   verbose,
  30.                   pageflag;
  31.  
  32. extern ref huge   *rhead;
  33. extern seg huge   **pas;
  34. extern imm huge   **pai;
  35. extern expr huge  **pae;
  36.  
  37. word                    endpc, diff, r_end, r_start, head_off, rcode_off;
  38.  
  39. extern lword            magic;
  40. extern byte       huge  *pb;
  41. extern e_dropped  huge  *pe;
  42. extern s_dropped  huge  *ps;
  43. extern linksymbol huge  *py;
  44. extern i_dropped  huge  *pi;
  45. extern r_dropped  huge  *pr;
  46. extern f_dropped  huge  *pf;
  47. extern lword            magic, bytes, sbytes, ibytes, rbytes, ebytes,
  48.                         ybytes, fbytes;
  49.  
  50.  
  51.  
  52. void pro_init()
  53. {
  54.    ENTER("pro_init");
  55.    __p  = __program = nmalloc( MAXMODULE);
  56.    __pc = origin;
  57.    if( ! bootable)
  58.    {
  59.       _deposit( 255);             /* drop binary header */
  60.       _deposit( 255);
  61.       dpoke( __p, __pc);
  62.       _advance( 2);              /* leave some room */
  63.       ptohead = __p;
  64.       _advance( 2);
  65.       head_off = rcode_off = 6;
  66.    }
  67.    else
  68.       if( bootable == 1)
  69.       {
  70.          _deposit( 0);
  71.          ptohead = __p;
  72.          _advance( 1);
  73.          dpoke( __p, __pc);
  74.          _advance( 4);
  75.          head_off = 6;
  76.       }
  77.  
  78.    if( relocatable)
  79.    {
  80.       _deposit( 0x4C);        /* JMP */
  81.       head_off  += 3;
  82.       rcode_off += 3;
  83.       __pc      += 3;
  84.       _advance( 2);
  85.       def_label( "|R_START", __pc);
  86.    }
  87.    r_start = __pc;
  88.    LEAVE();
  89. }
  90.  
  91.  
  92. void pro_exit()
  93. {
  94.    extern int  runad;
  95.  
  96.    ENTER("pro_exit");
  97.    if( ! bootable)
  98.    {
  99.       if( ptohead == __p - 2)          /* kill trailing empty segment */
  100.          __p -= 4;
  101.       else
  102.       {
  103.          dpoke( ptohead, __pc - 1);
  104.       }
  105.       if( runad)
  106.       {
  107.          wdeposit( 0x2E0);
  108.          wdeposit( 0x2E1);
  109.          wdeposit( origin);
  110.       }
  111.    }
  112.    else
  113.       if( bootable == 1)
  114.       {
  115.          label       *p;
  116.  
  117.          poke( ptohead, 1 + (__pc - dpeek( ptohead + 1)) / 0x80);
  118.          if( p = find_label( "_BOOT_INIT"))
  119.          {
  120.             dpoke( ptohead + 3, p->val);
  121.          }
  122.          else
  123.             nwarning( "_BOOT_INIT was not defined. That might lead to \
  124. problems, if your\nbootcode returns and the OS JSRs thru the init address");
  125.       }
  126.    if( __p == (__program + head_off))
  127.       nerror("Not a single byte was generated");
  128.    LEAVE();
  129. }
  130.  
  131.  
  132. void aload( afile, hflag)
  133. char  *afile;                     /* 3 'V's: Van Halen, VfL und Veltins! */
  134. {
  135.    char  *x;
  136.    int   fd;
  137.  
  138.    ENTER("aload");
  139.    INTEGRITY_CHECK();
  140. #if LOWERFILE
  141.    downcase( afile);
  142. #endif
  143.    IMESS( "Trying to open \"%s\" ", (lword) afile, 4);
  144.    if( (fd = (int) Fopen( afile, OPEN_R)) < 0)
  145.    {
  146.       if( hflag)
  147.       {
  148.          INTEGRITY_CHECK();
  149.          x = (char *) nmalloc( strlen( afile) + strlen( header) + 2L);
  150.          strcpy( x, header);
  151.          strcat( x, afile);
  152.          INTEGRITY_CHECK();
  153.       }
  154.       else
  155.       {
  156.          INTEGRITY_CHECK();
  157.          x = (char *) nmalloc( strlen( afile) + 6L);
  158.          strcpy( x, afile);
  159.          complete( x, ".o65", 1);
  160.          INTEGRITY_CHECK();
  161.       }
  162.       if( (fd = (int) Fopen( currfile = x, OPEN_R)) < 0)
  163.       {
  164.          if( fd == -35)
  165.             nferror("Out of GEMDOS file handles (that's strange..) ?)");
  166.          nferror( "Object file does not exist");
  167.       }
  168.    }
  169.    if( verbose)
  170.       printf( "%-16s ", afile);
  171.    INTEGRITY_CHECK();
  172.    do_load( fd);
  173.    INTEGRITY_CHECK();
  174.    Fclose( fd);
  175.    LEAVE();
  176. }
  177.  
  178. /* ---------------------------------------------------------- */
  179. /*    Wrapup .. Stuff to do, when we are thru with updating   */
  180. /* the symbol table and relocating the code. A new file might */
  181. /* be read in after this.                                     */
  182. /* ---------------------------------------------------------- */
  183. void wrapup()
  184. {
  185.    ENTER("wrapup");
  186.    nfree( pas);
  187.    nfree( pai);
  188.    MESS("pae");
  189.    nfree( pae);
  190.    nfree( pb);
  191.    MESS("py");
  192.    nfree( py);
  193.    nfree( pe);
  194.    MESS("pr");
  195.    nfree( pr);
  196.    nfree( pi);
  197.    MESS("ps");
  198.    nfree( ps);
  199.    nfree( pf);  /* v--- The meek shall inherit shit [DLR] */
  200.    rhead = (ref *)       (pae
  201.           = (expr **)     (pas
  202.            = (seg **)      (pai
  203.             = (imm **)      (ps
  204.              = (s_dropped *) (pi
  205.               = (i_dropped *) (pr
  206.                = (r_dropped *) (pf
  207.                 = (f_dropped *) (pe
  208.                  = (e_dropped *) (pb
  209.                   = (byte      *) (py = 0) )))))))));
  210. #if ! VERSION
  211.    check_trees();
  212. #endif
  213.    ALEAVE();
  214. }
  215.  
  216.  
  217. void write_results( fd)                   /* 4 'V's: Van Halen, VfL, Veltins und Vrauen! y */
  218. {
  219.    static char    err[] = "Write to output file failed (Disk full??)";
  220.    long           tbytes;
  221.  
  222.    ENTER("write_results");
  223.    tbytes = (long) (__p - __program);
  224.    if( bootable)                          /* make it sector sized */
  225.    {
  226.       word  tmp;
  227.  
  228.       if( tmp = (word) tbytes & 0x7F)
  229.          tbytes += (tmp ^ 0x7F) + 1;
  230.    }
  231.    if( verbose)
  232.       printf("\t\t End  : $%04X  Size:%5ld bytes total\n",
  233.                   __pc - 1, (lword) __pc - origin - 1);
  234.    if( Fwrite( fd, tbytes, __program) != tbytes)
  235.       nferror( err);
  236. #if STATISTICS
  237.    fprintf( ESTREAM, "%ld bytes of binary written\n", tbytes);
  238. #endif
  239.    Fclose( fd);
  240.    LEAVE();
  241. }
  242.  
  243. /* ---------------------------------------------------------- */
  244. /*           Mallocer for identifier and other strings        */
  245. /*                                                            */
  246. /*  (Keeping the fingers crossed that this is faster than a)  */
  247. /*                       (simple malloc)                      */
  248. /* ---------------------------------------------------------- */
  249. typedef struct _str_m
  250. {
  251.    long                 free;
  252.    char huge            *space;
  253.    struct _str_m huge   *before;
  254. } str_m;
  255.  
  256. static str_m huge *st_h;
  257.  
  258.  
  259. char   *str_alloc( size)
  260. int   size;
  261. {
  262.    register str_m huge  *p;
  263.    register char  huge  *q;
  264.    extern   word        _a_char, _m_char;
  265.    extern  lword        _z_char, _s_char;
  266.  
  267.    ENTER("str_alloc");
  268. #if STATISTICS
  269.    _a_char++;
  270.    _z_char += size;
  271. #endif
  272.    if( (p = st_h) && p->free >= size)
  273.    {
  274. letsdoit:
  275.       p->free  -= size;
  276.       q         = p->space;
  277.       p->space += size;
  278.       IMESS("sending $%lX as address", (lword) q, 4);
  279.       LEAVE();
  280.       return( q);
  281.    }
  282. #if STATISTICS
  283.    _m_char++;
  284.    _s_char = sizeof(str_m) + STRMAX;
  285. #endif
  286.    p         = (str_m *) nmalloc( sizeof(str_m) + STRMAX);
  287.    p->free   = STRMAX;
  288.    p->space  = (char huge *) p + sizeof( str_m);
  289.    p->before = st_h;
  290.    st_h  = p;
  291.    if( size > STRMAX)
  292.       nierror("Unexpected internal problems force NLINK65 to crash");
  293.    goto letsdoit;
  294. }
  295.  
  296.  
  297.  
  298.  
  299. /* y  Har har */
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.