home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 1 / APDL_PD1A.iso / program / assembler / as / src / c / option < prev    next >
Encoding:
Text File  |  1992-08-04  |  7.3 KB  |  303 lines
  1.  
  2. /*
  3.  * option.c
  4.  * Copyright © 1992 Niklas Röjemo
  5.  */
  6.  
  7. #include <ctype.h>
  8. #include "option.h"
  9. #include "error.h"
  10. #include "input.h"
  11.  
  12. extern int pedantic;
  13.  
  14. static WORD getCond(void)
  15. {
  16.   WORD cc;
  17.   switch(inputLook()) {
  18.     case 'a':case 'A':
  19.       switch(inputLookN(1)) {
  20.         case 'l':case 'L':  cc = AL; inputSkipN(2); break;
  21.         default:   cc = AL;
  22.       }
  23.       break;
  24.     case 'c':case 'C':
  25.       switch(inputLookN(1)) {
  26.         case 'c':case 'C': cc = CC; inputSkipN(2); break;
  27.         case 's':case 'S': cc = CS; inputSkipN(2); break;
  28.         default:  cc = AL;
  29.       }
  30.       break;
  31.     case 'e':case 'E':
  32.       switch(inputLookN(1)){
  33.         case 'q':case 'Q': cc = EQ; inputSkipN(2); break;
  34.         default:  cc = AL;
  35.       }
  36.       break;
  37.     case 'g':case 'G':
  38.       switch(inputLookN(1)) {
  39.         case 'e':case 'E': cc = GE; inputSkipN(2); break;
  40.         case 't':case 'T': cc = GT; inputSkipN(2); break;
  41.         default:  cc = AL;
  42.       }
  43.       break;
  44.     case 'h':case 'H':
  45.       switch(inputLookN(1)) {
  46.         case 'i':case 'I': cc = HI; inputSkipN(2); break;
  47.         case 's':case 'S': cc = HS; inputSkipN(2); break;
  48.         default:  cc = AL;
  49.       }
  50.       break;
  51.     case 'l':case 'L':
  52.       switch(inputLookN(1)) {
  53.         case 'e':case 'E': cc = LE; inputSkipN(2); break;
  54.         case 'o':case 'O': cc = LO; inputSkipN(2); break;
  55.         case 's':case 'S': cc = LS; inputSkipN(2); break;
  56.         case 't':case 'T': cc = LT; inputSkipN(2); break;
  57.         default:  cc = AL;
  58.       }
  59.       break;
  60.     case 'm':case 'M':
  61.       switch(inputLookN(1)) {
  62.         case 'i':case 'I': cc = MI; inputSkipN(2); break;
  63.         default:  cc = AL;
  64.       }
  65.       break;
  66.     case 'n':case 'N':
  67.       switch(inputLookN(1)) {
  68.         case 'e':case 'E': cc = NE; inputSkipN(2); break;
  69.         case 'v':case 'V': cc = NV; inputSkipN(2); break;
  70.         default:  cc = AL;
  71.       }
  72.       break;
  73.     case 'p':case 'P':
  74.       switch(inputLookN(1)) {
  75.         case 'l':case 'L': cc = PL; inputSkipN(2); break;
  76.         default:  cc = AL;
  77.       }
  78.       break;
  79.     case 'v':case 'V':
  80.       switch(inputLookN(1)) {
  81.         case 'c':case 'C': cc = VC; inputSkipN(2); break;
  82.         case 's':case 'S': cc = VS; inputSkipN(2); break;
  83.         default:  cc = AL;
  84.       }
  85.       break;
  86.     default: cc = AL;
  87.   }
  88.   return cc;
  89. } 
  90.  
  91. static WORD getDir(BOOL ldm)
  92. {
  93.   WORD dir;
  94.   switch(inputLook()) {
  95.     case 'd':case 'D':
  96.       switch(inputLookN(1)) {
  97.         case 'b':case 'B': dir = DB; inputSkipN(2); break;
  98.         case 'a':case 'A': dir = DA; inputSkipN(2); break;
  99.         default: goto illegal;
  100.       }
  101.       break;
  102.     case 'e':case 'E':
  103.       switch(inputLookN(1)) {
  104.         case 'd':case 'D': dir = (ldm?IB:DA); inputSkipN(2); break;
  105.         case 'a':case 'A': dir = (ldm?DB:IA); inputSkipN(2); break;
  106.         default: goto illegal;
  107.       }
  108.       break;
  109.     case 'f':case 'F':
  110.       switch(inputLookN(1)) {
  111.         case 'd':case 'D': dir = (ldm?IA:DB); inputSkipN(2); break;
  112.         case 'a':case 'A': dir = (ldm?DA:IB); inputSkipN(2); break;
  113.         default: goto illegal;
  114.       }
  115.       break;
  116.     case 'i':case 'I':    
  117.       switch(inputLookN(1)) {
  118.         case 'b':case 'B': dir = IB; inputSkipN(2); break;
  119.         case 'a':case 'A': dir = IA; inputSkipN(2); break;
  120.         default: goto illegal;
  121.       }
  122.       break;
  123.     default:
  124. illegal:
  125.       return optionError;
  126.   }
  127.   return dir;
  128. }
  129.  
  130. static WORD getPrec(int P)
  131. {
  132.   switch(inputGet()) {
  133.     case 's': case 'S': return P?PRECISION_MEM_SINGLE:PRECISION_SINGLE; 
  134.     case 'd': case 'D': return P?PRECISION_MEM_DOUBLE:PRECISION_DOUBLE; 
  135.     case 'e': case 'E': return P?PRECISION_MEM_EXTENDED:PRECISION_EXTENDED; 
  136.     case 'p': case 'P': return P?PRECISION_MEM_PACKED:optionError;
  137.   }
  138.   return optionError;
  139. }
  140.  
  141. static WORD getRound(void)
  142. {
  143.   switch(inputLook()) {
  144.     case 'p': case 'P': inputSkip(); return ROUND_PLUSINF; 
  145.     case 'm': case 'M': inputSkip(); return ROUND_MINUSINF; 
  146.     case 'z': case 'Z': inputSkip(); return ROUND_ZERO;
  147.   }
  148.   return ROUND_NEAREST;
  149. }
  150.  
  151. static WORD isOK(WORD option)
  152. {
  153.   if(!isspace(inputGet()))
  154.     return optionError;
  155.   else
  156.     return option;
  157. }  
  158. WORD optionCond(void)
  159. {
  160.   return isOK(getCond());
  161. }
  162.  
  163. WORD optionCondS(void)
  164. {
  165.   WORD option = getCond();
  166.   if(inputLook() == 's' || inputLook() == 'S') {
  167.     option |= S_FLAG;
  168.     inputSkip();
  169.   }
  170.   return isOK(option);
  171. }
  172.   
  173. WORD optionCondSP(void)
  174. {
  175.   WORD option = getCond() | S_FLAG;
  176.   if(inputLook() == 's' || inputLook() == 'S') { 
  177.     inputSkip();
  178.     if(pedantic) error(ErrorInfo,TRUE,"S is implicit in test instructions.");
  179.   }
  180.   if(inputLook() == 'p' || inputLook() == 'P') {
  181.     option |= P_FLAG;
  182.     inputSkip();
  183.   }
  184.   return isOK(option);
  185. }
  186.  
  187. WORD optionCondB(void)
  188. {
  189.   WORD option = getCond();
  190.   if(inputLook() == 'b' || inputLook() == 'B') {
  191.     option |= B_FLAG;
  192.     inputSkip();
  193.   }
  194.   return isOK(option);
  195. }
  196.  
  197. WORD optionCondBT(void)
  198. {
  199.   WORD option = getCond();
  200.   if(inputLook() == 'b' || inputLook() == 'B') {
  201.     option |= B_FLAG;
  202.     inputSkip();
  203.   }
  204.   if(inputLook() == 't' || inputLook() == 'T') {
  205.     option |= T_FLAG;
  206.     inputSkip();
  207.   }
  208.   return isOK(option);
  209. }
  210.  
  211. WORD optionCondDirLdm(void)
  212. {
  213.   WORD option = getCond();
  214.   if(optionError == (option |= getDir(TRUE)))
  215.     return optionError;
  216.   return isOK(option);
  217. }
  218.  
  219. WORD optionCondDirStm(void)
  220. {
  221.   WORD option = getCond();
  222.   if(optionError == (option |= getDir(FALSE)))
  223.     return optionError;
  224.   return isOK(option);
  225. }
  226.  
  227. WORD optionCondPrecRound(void)
  228. {
  229.   WORD option = getCond();
  230.   if(optionError == (option |= getPrec(FALSE)))
  231.     return optionError;
  232.   return isOK(option | getRound());
  233. }
  234.  
  235. WORD optionCondPrec_P(void)
  236. {
  237.   WORD option = getCond();
  238.   if(optionError == (option |= getPrec(TRUE)))
  239.     return optionError;
  240.   return isOK(option);
  241. }
  242.  
  243. WORD optionCondL(void)
  244. {
  245.   WORD option = getCond();
  246.   if(inputLook() == 'l' || inputLook() == 'L') {
  247.     option |= L_FLAG;
  248.     inputSkip();
  249.   }
  250.   return isOK(option);
  251. }
  252.  
  253. /****** Trouble mnemonics **********/
  254.  
  255. WORD optionLinkCond(void)   /* 'b' is matched before call */
  256. {
  257.   if(inputLook() != 'l' && inputLook() != 'L') { /* Only b.CC possible  */
  258.     return isOK(getCond());
  259.   } else {
  260.     inputSkip();                                 /* bl.CC or b.l?  */
  261.     switch(inputLook()) {
  262.       case 'e':case 'E':                         /* b.le or bl.eq */
  263.           inputSkip();
  264.         switch(inputLook()) {
  265.           case 'q': case 'Q':                    /* Only bl.eq */
  266.             inputSkip(); 
  267.             return isOK(EQ|LINK_BIT);
  268.           default:                               /* Only b.le */
  269.             return isOK(LE);
  270.         }
  271.       case 'o':case 'O': /* Only b.lo possible */
  272.         inputSkip();
  273.         return isOK(LO);
  274.       case 's':case 'S': /* Only b.ls possible */
  275.         inputSkip();
  276.         return isOK(LS);
  277.       case 't':case 'T': /* Only b.lt possible */
  278.         inputSkip();
  279.         return isOK(LT);
  280.       default:  /* Only bl.CC possible */
  281.         return isOK(getCond() | LINK_BIT);
  282.     }
  283.   }
  284.   return optionError;
  285. }
  286.  
  287. WORD optionExceptionCond(void)
  288. { 
  289.   int c;
  290.   if(inputLook() != 'e' && inputLook() != 'E') { /* Only cmf.CC possible  */
  291.     return isOK(getCond());
  292.   } else {        /* cmf.eq or cmfe.CC */
  293.     inputSkip();
  294.     if((c=inputLook()) == 'q' || c == 'Q') {   /* Only cmf.eq */
  295.       inputSkip();
  296.       return isOK(EQ);
  297.     } else {                                   /* Only cmfe.CC */
  298.       return isOK(getCond()|EXEPTION_BIT);
  299.     }
  300.   }
  301.   return optionError;
  302. }
  303.