Return to cmd_write.c CVS log

Up to [Coherent Logic Development] / freem / src

Annotation of freem/src/cmd_write.c, revision 1.4

1.1       snw         1: /*
1.4     ! snw         2:  *   $Id: cmd_write.c,v 1.3 2025/03/09 19:14:24 snw Exp $
1.1       snw         3:  *    Implementation of the WRITE command
                      4:  *
                      5:  *  
1.2       snw         6:  *   Author: Serena Willis <snw@coherent-logic.com>
1.1       snw         7:  *    Copyright (C) 1998 MUG Deutschland
                      8:  *    Copyright (C) 2023 Coherent Logic Development LLC
                      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.4     ! snw        26:  *   $Log: cmd_write.c,v $
        !            27:  *   Revision 1.3  2025/03/09 19:14:24  snw
        !            28:  *   First phase of REUSE compliance and header reformat
        !            29:  *
1.3       snw        30:  *
                     31:  * SPDX-FileCopyrightText:  (C) 2025 Coherent Logic Development LLC
                     32:  * SPDX-License-Identifier: AGPL-3.0-or-later
1.1       snw        33:  **/
                     34: 
                     35: #include <string.h>
                     36: #include <stdlib.h>
                     37: #include "mpsdef.h"
                     38: #include "mcommand.h"
                     39: #if !defined(MSDOS)
                     40: # include "io_socket.h"
                     41: #endif
                     42: 
                     43: MRESULT cmd_write(MACTION *ra, int *i)
                     44: {
                     45:     char vn[255];
                     46:     char *wr_terminator = (char *) malloc (STRLEN * sizeof (char));
1.4     ! snw        47:     char *sw_buf = (char *) malloc (BIGSTR * sizeof (char));
1.1       snw        48:     
                     49:     NULLPTRCHK(wr_terminator,"cmd_write");
                     50:     NULLPTRCHK(sw_buf,"cmd_write");
                     51: 
                     52:     if (io > FIRSTSCK) msck_get_terminator (io, wr_terminator);
                     53:     
                     54:     if (io != HOME && devopen[io] == 'r' && io < FIRSTSCK) {
                     55:         free (sw_buf);
                     56:         return NOWRITE;
                     57:     }
                     58:     
                     59:     if ((*i = (*codptr)) == SP || *i == EOL) {
                     60:         return ARGLIST;
                     61:     }
                     62:     
                     63: writeproc:
                     64:     
                     65:     switch (*i)
                     66:     {
                     67:         
                     68:         case '!':
                     69:             
                     70:             if (io < FIRSTSCK) {
                     71:                 
                     72:                 if (crlf[io]) {
                     73:                     write_m ("\012\201");
                     74:                 }
                     75:                 else {
                     76:                     write_m ("\015\012\201");
                     77:                 }
                     78:                 
                     79:             }
                     80:             else {                
                     81:                 /* WRITE ! for sockets */
                     82:                 strcat (sw_buf, wr_terminator);                
                     83:             }
                     84:             
                     85:             break;
                     86:             
                     87:         case '#':
                     88:             
                     89:             if (io < FIRSTSCK) {
                     90:                 write_m ("\015\014\201");
                     91:             }
                     92:             else {
                     93:                 return SYNTERR;
                     94:             }
                     95:             
                     96:             break;
                     97:             
                     98:         case '?':
                     99:             
                    100:             codptr++;
                    101:             
                    102:             expr (STRING);
                    103:             
                    104:             if (merr ()) return merr ();
                    105:             
                    106:             if (io < FIRSTSCK) {
                    107:                 write_t ((short) intexpr (argptr));
                    108:             }
                    109:             else {
                    110:                 return SYNTERR;
                    111:             }
                    112:             
                    113:             break;
                    114:             
                    115:         case '/':
                    116:             codptr++;
                    117:             
                    118:             expr (NAME);
                    119:             if (merr ()) return merr ();
                    120:             
                    121:             if (io < FIRSTSCK) {
                    122:                 write_f (varnam);
                    123:             }
                    124:             else {
                    125:                 return SYNTERR;
                    126:             }
                    127:             
                    128:             codptr++;
                    129:             
                    130:             break;
                    131:             
                    132:         case '*':
                    133:             codptr++;
                    134:             
                    135:             expr (STRING);            
                    136:             if (merr ()) return merr ();
                    137:             
                    138:             argptr[0] = (char) UNSIGN (intexpr (argptr));
                    139:             argptr[1] = EOL;
                    140:             
                    141:             /* special treatment for EOL as long as we don't have 8 bit */
                    142:             if (argptr[0] == EOL) {
                    143:                 
                    144:                 mcmnd = '*';
                    145:                 
                    146:                 if (io < FIRSTSCK) {
                    147:                     m_output (argptr);
                    148:                 }
                    149:                 else {
                    150:                     /* EOL handling for socket devices */
                    151:                 }
                    152:                 mcmnd = WRITE;
                    153:                 
                    154:             }
                    155:             else {
                    156:                 
                    157:                 if (io < FIRSTSCK) {
                    158:                     write_m (argptr);
                    159:                 }
                    160:                 else {
                    161:                     /* non-EOL char-code handling for sockets */
                    162:                 }
                    163:                 
                    164:             }
                    165:             
                    166:             break;
                    167:             
                    168:         default:
                    169:             expr (STRING);            
                    170:             if (merr ()) return merr ();
                    171:             
                    172:             if (io < FIRSTSCK) {
                    173:                 write_m (argptr);
                    174:             }
                    175:             else {
                    176:                 /* regular output for socket devices */
                    177:                 stcpy (vn, argptr);
                    178:                 stcnv_m2c (vn);
                    179:                 strcat (sw_buf, vn);
                    180:             }
                    181:     }
                    182:     
                    183:     if ((*i == '!') || (*i == '#')) {
                    184:         if ((*i = *++codptr) == '!' || *i == '#' || *i == '?') goto writeproc;
                    185:     }
                    186:     
                    187:     if (io >= FIRSTSCK) {
                    188:         msck_write (io, sw_buf, strlen (sw_buf));
                    189:     }
                    190:     
                    191:     free (sw_buf);
                    192:     free (wr_terminator);
                    193:     
                    194:     *ra = RA_CONTINUE;
                    195:     return OK;    
                    196: }