home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 1 / APDL_PD1A.iso / program / assembler / as / src / c / code < prev    next >
Encoding:
Text File  |  1993-03-07  |  7.1 KB  |  259 lines
  1. /*
  2.  * code.c
  3.  * Copyright © 1992 Niklas Röjemo
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include "code.h"
  9. #include "error.h"
  10. #include "eval.h"
  11. #include "area.h"
  12. #include "option.h"
  13. #include "input.h"
  14. #include "AofFile.h"
  15. #include "storage.h"
  16.  
  17. static Code Program[CODE_SIZECODE];
  18. static int FirstFreeIns;
  19. static Value  Stack[CODE_SIZESTACK];
  20.  
  21. static LateInfo LateHeap[CODE_SIZELATE];
  22. static int      LateHeapPtr;
  23.  
  24. LateInfo *codeNewLateInfo(Symbol *symbol)
  25. {
  26.   if(LateHeapPtr<CODE_SIZELATE) {
  27.     LateHeap[LateHeapPtr].next = 0;
  28.     LateHeap[LateHeapPtr].factor = 1;
  29.     LateHeap[LateHeapPtr].symbol = symbol;
  30.   } else
  31.     error(ErrorSerious,FALSE,"Internal codeNewLateInfo: Out of memory.");
  32.   return &LateHeap[LateHeapPtr++];
  33. } 
  34.  
  35. void codeInit(void)
  36. {
  37.   FirstFreeIns = LateHeapPtr =0;
  38. }
  39.  
  40. void codeOperator(Operator op)
  41. {
  42.   if(FirstFreeIns<CODE_SIZECODE) {
  43.     Program[FirstFreeIns].Tag = CodeOperator;
  44.     Program[FirstFreeIns++].CodeOperator.op = op;
  45.   } else
  46.     error(ErrorSerious,FALSE,"Internal codeOp: Overflow.");
  47. }
  48.  
  49. void codeSymbol(Symbol *symbol)
  50. {
  51.   if(FirstFreeIns<CODE_SIZECODE) {
  52.     if(symbol->type & SYMBOL_DEFINED &&
  53.        !(symbol->type & SYMBOL_AREA)) {
  54.       switch(symbol->value.Tag) {
  55.         case ValueInt:    case ValueFloat:
  56.         case ValueString: case ValueBool:
  57.           Program[FirstFreeIns  ].Tag = CodeValue;
  58.           Program[FirstFreeIns++].CodeValue.value = symbol->value;
  59.           break;
  60.         case ValueCode:
  61.           if(FirstFreeIns+symbol->value.ValueCode.len<=CODE_SIZECODE) {
  62.             int i;
  63.             for(i=0; i<symbol->value.ValueCode.len; i++)
  64.               Program[FirstFreeIns++] = symbol->value.ValueCode.c[i];
  65.           } else
  66.             error(ErrorSerious,FALSE,"Internal codeSymbol: Overflow.(n)");
  67.           break;
  68.         default:
  69.           error(ErrorSerious,FALSE,"Internal codeSymbol:Illegal symbol value.");
  70.       }
  71.     } else {
  72.       Program[FirstFreeIns  ].Tag = CodeSymbol;
  73.       Program[FirstFreeIns++].CodeSymbol.symbol = symbol;
  74.     }
  75.   } else
  76.     error(ErrorSerious,FALSE,"Internal codeSymbol: Overflow.(1)");
  77. }
  78.  
  79. void codePosition(Symbol *area)
  80. {
  81.   if(area) {
  82.     codeSymbol(area);
  83.     codeInt(area->value.ValueInt.i);
  84.     codeOperator(Op_add);
  85.   } else
  86.     error(ErrorError,FALSE,"'.' but no area is defined.");
  87. }
  88.  
  89. void codeStorage(void)
  90. {
  91.   Value value = storageValue();  /* Must be ValueInt */
  92.   codeInt(value.ValueInt.i);
  93. }
  94.  
  95. void codeString(int len, char *str)
  96. {
  97.   if(FirstFreeIns<CODE_SIZECODE) {
  98.     Program[FirstFreeIns].Tag = CodeValue;
  99.     Program[FirstFreeIns].CodeValue.value.Tag = ValueString;
  100.     Program[FirstFreeIns].CodeValue.value.ValueString.len = len;
  101.     Program[FirstFreeIns++].CodeValue.value.ValueString.s = str;
  102.   } else
  103.     error(ErrorSerious,FALSE,"Internal codeString: Overflow.");
  104. }
  105.  
  106. void codeInt(int value)
  107. {
  108.   if(FirstFreeIns<CODE_SIZECODE) {
  109.     Program[FirstFreeIns].Tag = CodeValue;
  110.     Program[FirstFreeIns].CodeValue.value.Tag = ValueInt;
  111.     Program[FirstFreeIns++].CodeValue.value.ValueInt.i = value;
  112.   } else
  113.     error(ErrorSerious,FALSE,"Internal codeInt: Overflow.");
  114. }
  115.  
  116. void codeFloat(FLOAT value)
  117. {
  118.   if(FirstFreeIns<CODE_SIZECODE) {
  119.     Program[FirstFreeIns].Tag = CodeValue;
  120.     Program[FirstFreeIns].CodeValue.value.Tag = ValueFloat;
  121.     Program[FirstFreeIns++].CodeValue.value.ValueFloat.f = value;
  122.   } else
  123.     error(ErrorSerious,FALSE,"Internal codeFloat: Overflow.");
  124. }
  125.  
  126.  
  127. int Sp;  /* Used by codeEvalLow and codeEvalLowest */
  128.  
  129. static BOOL codeEvalLowest(int size, Code *program)  /* True if codeEvalLowest succeded */
  130. {
  131.   int Pp;
  132.   for(Pp=0; Pp<size; Pp++) {
  133.     switch(program[Pp].Tag) {
  134.     case CodeOperator:
  135.       if(program[Pp].CodeOperator.op == Op_neg ||
  136.          program[Pp].CodeOperator.op == Op_not ||
  137.          program[Pp].CodeOperator.op == Op_lnot) {
  138.         if(!evalUnop(program[Pp].CodeOperator.op,&Stack[Sp]))
  139.           return FALSE;
  140.       } else {
  141.         if(!evalBinop(program[Pp].CodeOperator.op,&Stack[Sp-1],&Stack[Sp]))
  142.           return FALSE;
  143.         Sp--;
  144.       }
  145.       break;
  146.     case CodeValue:
  147.       Stack[++Sp] = program[Pp].CodeValue.value;
  148.       break;
  149.     case CodeSymbol:
  150.       if (program[Pp].CodeSymbol.symbol->type & SYMBOL_DEFINED &&
  151.           !(program[Pp].CodeSymbol.symbol->type & SYMBOL_AREA)) { /* This can happen in the relocation phase. */
  152.         switch(program[Pp].CodeSymbol.symbol->value.Tag) {
  153.           case ValueInt:    case ValueFloat:
  154.           case ValueString: case ValueBool:
  155.             Stack[++Sp] = program[Pp].CodeSymbol.symbol->value;
  156.             break;
  157.           case ValueCode:
  158.             if(!codeEvalLowest(program[Pp].CodeSymbol.symbol->value.ValueCode.len,
  159.                                program[Pp].CodeSymbol.symbol->value.ValueCode.c))
  160.               return FALSE;
  161.             break;
  162.           default:
  163.             error(ErrorSerious,FALSE,
  164.                    "Internal codeEvalLow: Illegal value for symbol %s.",
  165.                    program[Pp].CodeSymbol.symbol->str);
  166.         }
  167.       } else {  /* Undefined or area or late register */
  168.         Stack[++Sp].Tag = ValueLateLabel;
  169.         Stack[  Sp].ValueLate.i = 0;
  170.         Stack[  Sp].ValueLate.late = codeNewLateInfo(program[Pp].CodeSymbol.symbol);
  171.       }
  172.       break;
  173.     default:
  174.       error(ErrorSerious,FALSE,"Internal codeEvalLow: Illegal expression.");
  175.     }
  176.   }
  177.   return TRUE;
  178. }
  179.  
  180. Value codeEval(ValueTag legal)
  181. {
  182.   return codeEvalLow(legal,FirstFreeIns,Program);
  183. }
  184.  
  185. Value codeEvalLow(ValueTag legal, int size, Code *program)
  186. {
  187.   Value Result;
  188.   Sp = -1;
  189.   if(!codeEvalLowest(size,program)) {
  190.     Result.Tag = ValueCode;
  191.     Result.ValueCode.len = size;
  192.     Result.ValueCode.c = program;
  193.   } else if(Sp == 0) {
  194.     Result = Stack[0];
  195.   } else {
  196.     Result.Tag = ValueIllegal;
  197.   }
  198.   if(!(Result.Tag & legal)) {
  199.     extern int pedantic,autocast;
  200.     if(autocast && legal & ValueFloat && Result.Tag == ValueInt) {
  201.       FLOAT f = Result.ValueInt.i;
  202.       if(pedantic) 
  203.         error(ErrorInfo,TRUE,"Changing integer %d to float %1.1f.",Result.ValueInt.i,f);
  204.       Result.Tag = ValueFloat;
  205.       Result.ValueFloat.f = f;
  206.     } else {
  207.       Result.Tag = ValueIllegal;
  208.     }
  209.   }
  210.   return Result;    
  211. }
  212.  
  213. Code *codeCopy(int len, Code *code)
  214. {
  215.   int i;
  216.   Code *new = malloc(len*sizeof(Code));
  217.   if(new) {
  218.     for(i=0; i<len; i++) {
  219.       switch(new[i].Tag = code[i].Tag) {
  220.         case CodeOperator:
  221.           new[i].CodeOperator.op = code[i].CodeOperator.op;
  222.           break;
  223.         case CodeValue:
  224.           new[i].CodeValue.value = valueCopy(code[i].CodeValue.value);
  225.           break;
  226.         case CodeSymbol:
  227.           new[i].CodeSymbol.symbol = code[i].CodeSymbol.symbol;
  228.           break;
  229.       }
  230.     }
  231.   } else
  232.     error(ErrorSerious,FALSE,"Internal codeCopy: Out of memory.");
  233.   return new;
  234. }
  235.  
  236. int codeEqual(int len, Code *a,Code *b)
  237. {
  238.   int i;
  239.   for(i=0; i<len; i++) {
  240.     if(a[i].Tag != b[i].Tag)
  241.       return FALSE;
  242.     switch(a[i].Tag) {
  243.       case CodeOperator:
  244.         if(a[i].CodeOperator.op != b[i].CodeOperator.op)
  245.           return FALSE;
  246.         break;
  247.       case CodeValue:
  248.         if(!valueEqual(&a[i].CodeValue.value,&b[i].CodeValue.value))
  249.           return FALSE;
  250.         break;
  251.       case CodeSymbol:
  252.         if(a[i].CodeSymbol.symbol != b[i].CodeSymbol.symbol)
  253.           return FALSE;
  254.         break;
  255.     }
  256.   }
  257.   return TRUE;
  258. }
  259.