Return to cmd_write.c CVS log

Up to [Coherent Logic Development] / freem / src

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

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