Return to mcommand.c CVS log

Up to [Coherent Logic Development] / freem / src

Annotation of freem/src/mcommand.c, revision 1.3

1.1       snw         1: /*
1.3     ! snw         2:  *   $Id$
1.1       snw         3:  *    M command utility functions
                      4:  *
                      5:  *  
1.2       snw         6:  *   Author: Serena Willis <snw@coherent-logic.com>
1.1       snw         7:  *    Copyright (C) 1998 MUG Deutschland
1.3     ! snw         8:  *    Copyright (C) 2023, 2025 Coherent Logic Development LLC
1.1       snw         9:  *
                     10:  *
                     11:  *   This file is part of FreeM.
                     12:  *
                     13:  *   FreeM is free software: you can redistribute it and/or modify
                     14:  *   it under the terms of the GNU Affero Public License as published by
                     15:  *   the Free Software Foundation, either version 3 of the License, or
                     16:  *   (at your option) any later version.
                     17:  *
                     18:  *   FreeM is distributed in the hope that it will be useful,
                     19:  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
                     20:  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     21:  *   GNU Affero Public License for more details.
                     22:  *
                     23:  *   You should have received a copy of the GNU Affero Public License
                     24:  *   along with FreeM.  If not, see <https://www.gnu.org/licenses/>.
                     25:  *
1.3     ! snw        26:  *   $Log$
        !            27:  *
        !            28:  * SPDX-FileCopyrightText:  (C) 2025 Coherent Logic Development LLC
        !            29:  * SPDX-License-Identifier: AGPL-3.0-or-later
1.1       snw        30:  **/
                     31: 
                     32: #include <string.h>
                     33: #include <stdlib.h>
                     34: #include "mpsdef.h"
                     35: #include "mcommand.h"
                     36: 
                     37: MRESULT mcmd_tokenize(MACTION *ra, char *tmp3, char *deferrable_codptr, char *deferrable_code, int *j)
                     38: {
                     39:     tmp3[0] = SP;
                     40:     tmp3[1] = mcmnd;
                     41:     tmp3[++(*j)] = SP;
                     42:     tmp3[++(*j)] = EOL;
                     43:     
                     44:     if (mcmnd != 'z') {
                     45:         
                     46:         if (find (" ab ablock assert assign asta astart asto astop aunb aunblock \
                     47:             break co const close do else esta estart esto estop etr etrigger for goto hang halt \
                     48:             if job kill ks ksubscripts kv kvalue lock ma map merge new open quit read rl rload \
                     49:             rs rsave set tc tcommit th then thr throw tro trollback ts tstart use \
                     50:             un unmap usi using view wa watch write wi with xecute ", tmp3) == FALSE) {
                     51:             return CMMND;
                     52:         }
                     53: 
                     54:         switch (mcmnd)
                     55:         {
                     56:             
                     57:             case 'a':
                     58:                 
                     59:                 if (tmp3[2] == 'b') {
                     60:                     mcmnd = ABLOCK;
                     61:                 }
                     62:                 else if (tmp3[2] == 'u') {
                     63:                     mcmnd = AUNBLOCK;
                     64:                 }
                     65:                 else if (tmp3[2] == 's') {
                     66:                     
                     67:                     if (tmp3[4] == 'a') {
                     68:                         mcmnd = ASTART;
                     69:                     }                 
                     70:                     else if (tmp3[4] == 'o') {
                     71:                         mcmnd = ASTOP;
                     72:                     }
                     73:                     else if (tmp3[4] == 'e') {
                     74:                         mcmnd = ASSERT_TKN;
                     75:                     }
                     76:                     
                     77:                 }
                     78:                
                     79:                 break;
                     80:                 
                     81:             case 'c':
                     82:                 
                     83:                 if (tmp3[2] == 'l') {
                     84:                     mcmnd = CLOSE;
                     85:                 }
                     86:                 else {
                     87:                     mcmnd = CONST;
                     88:                 }
                     89:                
                     90:             case 'e':
                     91:                 if (tmp3[2] == 't') mcmnd = ETRIGGER;
                     92:                 else if (tmp3[4] == 'a') mcmnd = ESTART;
                     93:                 else if (tmp3[4] == 'o') mcmnd = ESTOP;
                     94:                 break;
                     95:                
                     96:             case 'h':
                     97:                 mcmnd = tmp3[4] == 't' ? HALT : HANG;
                     98:                 break;
                     99:                
                    100:             case 'k':
                    101:                 if (tmp3[2] == 'v') mcmnd = KVALUE;
                    102:                 else if (tmp3[2] == 's') mcmnd = KSUBSC;
                    103:                 break;
                    104:                
                    105:             case 'm':
                    106:                 
                    107:                 if (tmp3[2] == 'e') {
                    108:                     
                    109:                     /* save off pre-parse codptr and code for commands implemented in M routines */
                    110:                     deferrable_codptr = codptr;
                    111:                     stcpy (deferrable_code, "MERGE\201");
                    112:                     stcat (deferrable_code, deferrable_codptr);
                    113:                    
                    114:                     break;
                    115:                     
                    116:                 }
                    117:                 else if (tmp3[2] == 'a') {
                    118:                     mcmnd = MAP;
                    119:                     break;
                    120:                 }
                    121:                
                    122:             case 'r':
                    123:                 if (tmp3[2] == 'l') mcmnd = RLOAD;
                    124:                 else if (tmp3[2] == 's') mcmnd = RSAVE;
                    125:                 break;
                    126:                
                    127:             case 't':
                    128:                 if (tmp3[2] == 'c') mcmnd = TCOMMIT;
                    129:                 else if (tmp3[2] == 'h') {
                    130:                     if (tmp3[3] == 'e') {
                    131:                         mcmnd = THEN;
                    132:                     }
                    133:                     else if (tmp3[3] == 'r') {
                    134:                         mcmnd = THROW;
                    135:                     }
                    136:                 }
                    137:                 else if (tmp3[3] == 'o') mcmnd = TROLLBACK;
                    138:                 else if (tmp3[2] == 's') mcmnd = TSTART;
                    139:                 break;
                    140:                
                    141:             case 'w':
                    142:                 
                    143:                 switch (tmp3[2]) {
                    144:                     
                    145:                     
                    146:                     case 'a':
                    147:                         mcmnd = WATCH;
                    148:                         break;
                    149:                         
                    150:                     case 'i':
                    151:                         mcmnd = OO_WITH;
                    152:                         break;
                    153:                        
                    154:                     case 'r':
                    155:                         mcmnd = WRITE;
                    156:                         break;
                    157:                         
                    158:                        
                    159:                 }                  
                    160:                 
                    161:                 break;
                    162:                 
                    163:             case 'u':
                    164:                 
                    165:                 if (tmp3[2] == 'n') {
                    166:                     mcmnd = UNMAP;
                    167:                     break;
                    168:                 }
                    169:                 
                    170:                 switch (tmp3[3]) {
                    171:                     
                    172:                     case 'e':
                    173:                         mcmnd = USE;
                    174:                         break;
                    175:                         
                    176:                     case 'i':
                    177:                         mcmnd = OO_USING;
                    178:                         break;
                    179:                         
                    180:                 }
                    181:                 
                    182:                
                    183:         }           /* end of switch(mcmnd) */
                    184:         
                    185:     }
                    186:     else {
                    187:         
                    188:         mcmnd = tmp3[2] - 32;   /* z_command select */
                    189:         
                    190:         if (find (zcommds, tmp3) == FALSE) mcmnd = PRIVATE;
                    191:     }
                    192: 
                    193:     *ra = RA_CONTINUE;
                    194:     return OK;
                    195: }