home *** CD-ROM | disk | FTP | other *** search
/ 8bitfiles.net/archives / archives.tar / archives / genie-commodore-file-library / C64-128Toolkit / CASSM.SFX / assm5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-27  |  6.5 KB  |  407 lines
  1. /*
  2.  * 6502 ┴SSEMBLER ╧BJECT ╧UPTPUT
  3.  * ╞ILENAME:  ASSM5.C
  4.  *
  5.  */
  6.  
  7.  
  8. #INCLUDE <STDIO.H>
  9. #INCLUDE "ASSM.D1"
  10. #INCLUDE "ASSM.D2"
  11.  
  12. /*
  13.  * ╘HE STRUCTURES DESCRIBING THE VARIOUS
  14.  * EXTERNAL AND RELOCATABLE OBJECTS MUST
  15.  * ALL HAVE A LINK POINTER AS THE FIRST
  16.  * FIELD, SO THEY MAY BE PROCESSED USING
  17.  * A COMMON ROUTINE.  ╙TRUCT EXTREC IS
  18.  * A GENERIC NAME FOR THIS COMMON STRUCTURE.
  19.  */
  20.  
  21. STRUCT EXTREC /* GENERIC RELOCATION/EXTERNAL RECORD */
  22. █
  23.   STRUCT EXTREC *EXTñNEXT;
  24. ▌;
  25.  
  26. STRUCT RELREC /* RELOCATION RECORD */
  27. █
  28.   STRUCT RELREC *RELñNEXT;
  29.   UNSIGNED RELñOFFSET;
  30. ▌;
  31.  
  32. STRUCT DEFREC /* EXTERNAL DEFINITION */
  33. █
  34.   STRUCT DEFREC *DEFñNEXT;
  35.   STRUCT SYMTYPE *DEFñSYMDEF;
  36. ▌;
  37.  
  38. STRUCT REFREC /* EXTERNAL REFERENCE */
  39. █
  40.   STRUCT REFREC *REFñNEXT;
  41.   STRUCT SYMTYPE *REFñSYMDEF;
  42.   UNSIGNED MODCODE; /* 0,1 OR 2, PLUS (INCREMENT << 2) */
  43.   UNSIGNED REFñOFFSET;
  44. ▌;
  45.  
  46. STRUCT DATREC /* DATA SEGMENT */
  47. █
  48.   STRUCT DATREC *DATñNEXT;
  49.   STRUCT SYMTYPE *DATñSYMDEF;
  50.   UNSIGNED SIZE;
  51. ▌;
  52.  
  53. /* POINTERS TO THE ENDS OF FOUR CIRCULAR
  54.  * LISTS:
  55.  */
  56. #DEFINE ╥┼╠ 0
  57. #DEFINE ─┼╞ 1
  58. #DEFINE ╥┼╞ 2
  59. #DEFINE ─┴╘ 3
  60. STATIC STRUCT EXTREC *LISTTAIL[4];
  61. STATIC UNSIGNED CNT[4];
  62.  
  63. STATIC UNSIGNED OBJLOC;
  64.  
  65. /**************************************
  66.  *
  67.  * ┴DD ITEM TO A RELOCATION INFO LIST.
  68.  *
  69.  */
  70. ╓╧╔─ ADDREC(P, LIST)
  71. STRUCT EXTREC *P;
  72. CHAR LIST;
  73. █
  74.   STRUCT EXTREC *TAIL;
  75.  
  76.   TAIL = LISTTAIL[LIST];
  77.   IF ( TAIL )
  78.   █
  79.     P->EXTñNEXT = TAIL->EXTñNEXT;
  80.     TAIL->EXTñNEXT = P;
  81.   ▌
  82.   ELSE
  83.     P->EXTñNEXT = P;
  84.  
  85.   LISTTAIL[LIST] = P;
  86.   CNT[LIST]++;
  87.  
  88. #IFDEF ─┼╞╘╥┴├┼
  89.   IF (DFLAG)
  90.     PRINTF("┼XT/╥EL RECORD, TYPE %D\N", LIST);
  91. #ENDIF
  92. ▌
  93.  
  94. /*
  95.  * ┴DD LABEL DEFINITION TO RELOCATION INFO LIST.
  96.  *
  97.  */
  98. ╓╧╔─ ADDDEF(P)
  99. STRUCT SYMTYPE *P;
  100. █
  101.   STRUCT DEFREC *RP;
  102.  
  103.   IF (P->XDFLAG)
  104.   █
  105.     RP = (STRUCT DEFREC *) MAKEREC ( SIZEOF(STRUCT DEFREC) );
  106.     RP->DEFñSYMDEF = P;
  107.     ADDREC(RP,─┼╞); /* ADD TO INFO LIST */
  108.   ▌
  109. ▌
  110.  
  111. /* 
  112.  * ╧UTPUT OBJECT COUNT AND INITIALIZE
  113.  * REFERENCE LIST POINTERS
  114.  *
  115.  */
  116. ╓╧╔─ PUTOC()
  117. █
  118.   CHAR I;
  119.  
  120.   PUTW(LOCCNT,OPTR); /* FIRST WORD IN OBJECT FILE */
  121.   FOR (I=0; I<4; I++)
  122.   █
  123.     LISTTAIL[I] = ╬╒╠╠;
  124.     CNT[I] = 0;
  125.   ▌
  126.   OBJLOC = 0;
  127. ▌
  128.  
  129. /* 
  130.  * ╧UTPUT EXTERNAL/RELOCATION ENTRIES AND
  131.  * FREE THE RECORDS
  132.  *
  133.  */
  134. ╓╧╔─ PUTRECS(LIST)
  135. CHAR LIST;
  136. █
  137.   STRUCT EXTREC *PTR, *NXTPTR;
  138.   STRUCT SYMTYPE *SP;
  139.   STRUCT RELREC *RELPTR;
  140.   STRUCT DEFREC *DEFPTR;
  141.   STRUCT REFREC *REFPTR;
  142.   STRUCT DATREC *DATPTR;
  143.  
  144.   PUTW(CNT[LIST], OPTR);
  145.   IF ((PTR = LISTTAIL[LIST])==╬╒╠╠)
  146.     RETURN;
  147.   NXTPTR = PTR->NEXT;
  148.   DO
  149.   █
  150.     PTR = NXTPTR;
  151.     SWITCH (LIST)
  152.     █
  153.     CASE ╥┼╠:
  154.       RELPTR = (STRUCT RELREC *) PTR;
  155.       PUTW(RELPTR->RELñOFFSET, OPTR);
  156.       BREAK;
  157.     CASE ─┼╞:
  158.       DEFPTR = (STRUCT DEFREC *) PTR;
  159.       SP = DEFPTR->DEFñSYMDEF;
  160.       PUTNAME(SP);
  161.       IF (ISREL(SP->FLAG))
  162.         FPUTC(1,OPTR);
  163.       ELSE
  164.         FPUTC(0,OPTR);
  165.       PUTW(SP->VALUE, OPTR);
  166.       BREAK;
  167.     CASE ╥┼╞:
  168.       REFPTR = (STRUCT REFREC *) PTR;
  169.       SP = REFPTR->REFñSYMDEF;
  170.       PUTNAME(SP);
  171.       PUTW(REFPTR->MODCODE, OPTR);
  172.       PUTW(REFPTR->REFñOFFSET, OPTR);
  173.       BREAK;
  174.     CASE ─┴╘:
  175.       DATPTR = (STRUCT DATREC *) PTR;
  176.       SP = DATPTR->DATñSYMDEF;
  177.       PUTNAME(SP);
  178.       PUTW(DATPTR->SIZE, OPTR);
  179.       BREAK;
  180.     ▌
  181.     NXTPTR = PTR->NEXT;
  182.     FREE(PTR);
  183.   ▌ WHILE ( PTR != LISTTAIL[LIST] );
  184. ▌
  185.  
  186. /* 
  187. ** ╧UTPUT SYMBOL NAME REFERENCE.
  188. **
  189. */
  190. ╓╧╔─ PUTNAME(SP)
  191. STRUCT SYMTYPE *SP;
  192. █
  193.   CHAR C;
  194.   CHAR *P;
  195.  
  196.   P = SP->NAME;
  197.   DO █
  198.     C = *P++;
  199.     FPUTC(C,OPTR);
  200.     ▌
  201.   WHILE (C);
  202. ▌
  203.  
  204. /*
  205. ** ┴LLOCATE SIZE BYTES OF STORAGE 
  206. ** ╥ETURNS: POINTER TO EMPTY ENTRY.
  207. **
  208. */
  209. CHAR *MAKEREC(SIZE)
  210. UNSIGNED SIZE;
  211. █
  212.   CHAR *PTR;
  213.  
  214.   PTR = MALLOC(SIZE);
  215.   IF (PTR==╬╒╠╠) █
  216.     ERROR(21);
  217.     QUIT();
  218.   ▌
  219.   RETURN (PTR);
  220. ▌
  221.  
  222. /*
  223.  * ├HECK THE CURRENT OBJECT BYTE AGAINST
  224.  * 'EXPRTYP' TO DETERMINE IF IT IS RELOCATABLE,
  225.  * OR MAKES AN EXTERNAL REFERENCE.
  226.  */
  227. ╓╧╔─ RELCHK(LOC)
  228. UNSIGNED LOC;
  229. █
  230.   STRUCT RELREC *RELPTR;
  231.   STRUCT REFREC *REFPTR;
  232.  
  233.   IF (ISREL(EXPRTYP) && !EXPRMC)
  234.   █
  235.     RELPTR = (STRUCT RELREC *) MAKEREC(SIZEOF(STRUCT RELREC));
  236.     RELPTR->RELñOFFSET = LOC;
  237.     ADDREC ( RELPTR, ╥┼╠ );
  238.   ▌
  239.   ELSE IF (EXPRTYP==╪╥┼╞ ▀▀ (ISREL(EXPRTYP) && EXPRMC))
  240.   █
  241.     REFPTR = (STRUCT REFREC *) MAKEREC(SIZEOF(STRUCT REFREC));
  242.     REFPTR->MODCODE = EXPRMC;
  243.     REFPTR->REFñOFFSET = LOC;
  244.     REFPTR->REFñSYMDEF = EXPRSYM;
  245.     IF (EXPRSYM->FLAG == ╪╥┼╞)
  246.     █
  247.       IF ( FULLVALUE >= 0X2000 && FULLVALUE < 0XE000 )
  248.         ERROR ( 11 );
  249.       REFPTR->MODCODE ▀= (FULLVALUE << 2);
  250.     ▌
  251.     ADDREC(REFPTR, ╥┼╞);
  252.   ▌
  253. ▌
  254.  
  255. /*
  256.  * ╨UT 1 BYTE VALUE TO OBJECT FILE,
  257.  * INCLUDING RELOCATION CHECK
  258.  *
  259.  */
  260. ╓╧╔─ PUT1R(V)
  261. UNSIGNED V;
  262. █
  263.   IF (OFLAG)
  264.   █
  265.     RELCHK(OBJLOC - 1);
  266.     PUT1(V);
  267.   ▌
  268. ▌
  269.  
  270. /*
  271.  * ╨UT 1 BYTE VALUE TO OBJECT FILE
  272.  *
  273.  * ╬OTE: NO RELOCATION CHECK PERFORMED
  274.  */
  275. ╓╧╔─ PUT1(V)
  276. UNSIGNED V;
  277. █
  278.   IF (OFLAG) █
  279.     FPUTC(V,OPTR);
  280.   ▌
  281.   OBJLOC++;
  282. ▌
  283.  
  284. /*
  285.  * ╨UT 2 BYTE VALUE TO OBJECT FILE
  286.  * 
  287.  */
  288. ╓╧╔─ PUT2(V1,V2)
  289. UNSIGNED V1,V2;
  290. █
  291.   IF (OFLAG) █
  292.     FPUTC(V1,OPTR);
  293.     FPUTC(V2,OPTR);
  294.     IF (EXPRMC)
  295.       RELCHK(OBJLOC);
  296.     ELSE
  297.       RELCHK(OBJLOC - 1);
  298.   ▌
  299.   OBJLOC += 2;
  300. ▌
  301. /*
  302.  * ╨UT 3 BYTES TO OBJECT FILE.
  303.  * ╞IRST VALUE IS OPCODE, SECOND IS
  304.  * OPERAND.
  305.  *
  306.  */
  307. ╓╧╔─ PUT3(V1,V2)
  308. UNSIGNED V1,V2;
  309. █
  310.   IF (OFLAG) █
  311.     FPUTC(V1,OPTR);
  312.     PUTW(V2,OPTR);
  313.     RELCHK(OBJLOC);
  314.   ▌
  315.   OBJLOC += 3;
  316. ▌
  317.  
  318. ╓╧╔─ PUTN(N)
  319. INT N;
  320. /*
  321.  * PUT N BYTES OF ZERO
  322.  */
  323. █
  324.   CHAR BUF[256];
  325.   INT I;
  326.  
  327.   OBJLOC += N;
  328.   IF (!OFLAG) RETURN;
  329.  
  330.   FOR (I=0; I<256; I++)
  331.     BUF[I] = 0;
  332.   WHILE ( N > 0 )
  333.   █
  334.     IF ( N >= 256 )
  335.       I = 256;
  336.     ELSE
  337.       I = N;
  338.     N -= I;
  339.     FWRITE ( BUF, I, 1, OPTR );
  340.   ▌
  341. ▌
  342.  
  343. /* CREATE A DATA SEGMENT */
  344.  
  345. ╓╧╔─ PUTDSEG( LEN )
  346. UNSIGNED LEN;
  347. █
  348.   STRUCT DATREC *PTR;
  349.  
  350.   PTR = (STRUCT DATREC *) MAKEREC(SIZEOF(STRUCT DATREC));
  351.   PTR->DATñSYMDEF = LABLPTR;
  352.   PTR->SIZE = LEN;
  353.   ADDREC(PTR,─┴╘);
  354. ▌
  355.  
  356. ╓╧╔─ HALFCHK ()
  357. /* ANY RELOCTABLE EXPRESSION USED WITH
  358.  * A '<' OR '>' OPERATION MUST BE MADE
  359.  * EXTERNAL, SINCE THE LINKER CANNOT
  360.  * RELOCATE HALF-ADDRESSES WHICH ARE NOT
  361.  * EXTERNAL.
  362.  */
  363. █
  364.   IF  ( EXPRMC )
  365.   █
  366.     IF ( EXPRSYM && EXPRSYM->XDFLAG )
  367.       RETURN;
  368.     IF ( ISABS ( EXPRTYP ) ▀▀ EXPRTYP==╪╥┼╞ )
  369.       RETURN;
  370.     STRCPY ( SYMBOL, ">" );
  371.     STRNCAT ( SYMBOL, FILENAME, ╙┬╧╠╙┌-5 );
  372.     HEXCON ( 4, FULLVALUE );
  373.     STRNCAT ( SYMBOL, HEX, 4 );
  374.     EXPRSYM = STLOOK ();
  375.     IF (PASS==╠┴╙╘ñ╨┴╙╙ && !EXPRSYM->XDFLAG)
  376.     █
  377.       EXPRSYM->FLAG = EXPRTYP;
  378.       EXPRTYP = ╪╥┼╞;
  379.       EXPRSYM->VALUE = FULLVALUE;
  380.       EXPRSYM->XDFLAG = 1;
  381.       IF (OFLAG) ADDDEF ( EXPRSYM );
  382.     ▌
  383.   ▌
  384. ▌
  385.  
  386. #IFDEF ╒╬╔╪
  387.  
  388. CHAR *INDEX(S,C)
  389. CHAR *S, C;
  390. █
  391.   WHILE (*S)
  392.     IF (C == *S) RETURN S;
  393.     ELSE S++;
  394.   RETURN 0;
  395. ▌
  396.  
  397. #ENDIF
  398.  
  399. ╓╧╔─ QUIT()
  400. █
  401. #IFDEF ╒╬╔╪
  402.   EXIT ( 1 );
  403. #ELSE
  404.   EXIT ();
  405. #ENDIF
  406. ▌
  407.