From 00e6bc749d15c262d708f7587fb45ca842e33dd2 Mon Sep 17 00:00:00 2001 From: Gregory Nutt Date: Sun, 2 Nov 2014 07:16:26 -0600 Subject: [PATCH] BAS: More modifications for closer comliance to the NuttX coding standard --- interpreters/bas/fs.c | 798 ++++++++++++++++++++++++++++++------------ 1 file changed, 575 insertions(+), 223 deletions(-) diff --git a/interpreters/bas/fs.c b/interpreters/bas/fs.c index f40a0883d..bc99df461 100644 --- a/interpreters/bas/fs.c +++ b/interpreters/bas/fs.c @@ -1,5 +1,61 @@ - -/* BASIC file system interface. */ +/**************************************************************************** + * apps/examples/interpreters/bas/value.c + * BASIC file system interface. + * + * Copyright (c) 1999-2014 Michael Haardt + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Adapted to NuttX and re-released under a 3-clause BSD license: + * + * Copyright (C) 2014 Gregory Nutt. All rights reserved. + * Authors: Alan Carvalho de Assis + * Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ /**************************************************************************** * Included Files @@ -71,9 +127,19 @@ static char FS_errmsgbuf[80]; volatile int FS_intr; #ifdef HAVE_TGETENT -static char *term, entrybuf[2048], *cap; -static char *cl, *cm, *ce, *cr, *md, *me, *AF, *AB; -static int Co, NC; +static char *term; +static char entrybuf[2048]; +static char *cap; +static char *cl; +static char *cm; +static char *ce; +static char *cr; +static char *md; +static char *me; +static char *AF; +static char *AB; +static int Co; +static int NC; #endif /**************************************************************************** @@ -87,7 +153,8 @@ static int size(int dev) int i; struct FileStream **n; - n = (struct FileStream **)realloc(file, (dev + 1) * sizeof(struct FileStream *)); + n = (struct FileStream **) + realloc(file, (dev + 1) * sizeof(struct FileStream *)); if (n == (struct FileStream **)0) { FS_errmsg = strerror(errno); @@ -117,7 +184,9 @@ static int opened(int dev, int mode) } if (mode == -1) - return 0; + { + return 0; + } switch (mode) { @@ -125,45 +194,60 @@ static int opened(int dev, int mode) { fd = file[dev]->outfd; if (fd == -1) - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), - _("channel #%d not opened for writing"), dev); + { + snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + _("channel #%d not opened for writing"), dev); + } break; } + case 1: { fd = file[dev]->infd; if (fd == -1) - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), - _("channel #%d not opened for reading"), dev); + { + snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + _("channel #%d not opened for reading"), dev); + } break; } + case 2: { fd = file[dev]->randomfd; if (fd == -1) - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), - _("channel #%d not opened for random access"), dev); + { + snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + _("channel #%d not opened for random access"), dev); + } break; } + case 3: { fd = file[dev]->binaryfd; if (fd == -1) - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), - _("channel #%d not opened for binary access"), dev); + { + snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + _("channel #%d not opened for binary access"), dev); + } break; } + case 4: { fd = (file[dev]->randomfd != -1 ? file[dev]->randomfd : file[dev]->binaryfd); if (fd == -1) - snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), - _("channel #%d not opened for random or binary access"), - dev); + { + snprintf(FS_errmsgbuf, sizeof(FS_errmsgbuf), + _("channel #%d not opened for random or binary access"), + dev); + } break; } + default: assert(0); } @@ -174,7 +258,9 @@ static int opened(int dev, int mode) return -1; } else - return 0; + { + return 0; + } } static int refill(int dev) @@ -213,7 +299,9 @@ static int edit(int chn, int onl) FS_putChar(chn, *buf ? (*buf + 'a' - 1) : '@'); } else - FS_putChar(chn, *buf); + { + FS_putChar(chn, *buf); + } } do { @@ -236,9 +324,14 @@ static int edit(int chn, int onl) { if (f->inBuf[f->inCapacity - 1] >= '\0' && f->inBuf[f->inCapacity - 1] < ' ') - FS_putChars(chn, "\b\b \b\b"); + { + FS_putChars(chn, "\b\b \b\b"); + } else - FS_putChars(chn, "\b \b"); + { + FS_putChars(chn, "\b \b"); + } + --f->inCapacity; } } @@ -252,10 +345,15 @@ static int edit(int chn, int onl) FS_putChar(chn, ch ? (ch + 'a' - 1) : '@'); } else - FS_putChar(chn, ch); + { + FS_putChar(chn, ch); + } } else if (onl) - FS_putChar(chn, '\n'); + { + FS_putChar(chn, '\n'); + } + f->inBuf[f->inCapacity++] = ch; } } @@ -269,11 +367,15 @@ static int outc(int ch) struct FileStream *f; if (opened(termchannel, 0) == -1) - return -1; + { + return -1; + } f = file[termchannel]; if (f->outSize + 1 >= f->outCapacity && FS_flush(termchannel) == -1) - return -1; + { + return -1; + } f->outBuf[f->outSize++] = ch; FS_errmsg = (const char *)0; @@ -311,12 +413,14 @@ static int initTerminal(int chn) FS_errmsg = _("reading terminal description failed"); return -1; } + case 0: { sprintf(FS_errmsgbuf, _("unknown terminal type %s"), term); FS_errmsg = FS_errmsgbuf; return -1; } + case 1: { cl = tgetstr("cl", &cap); @@ -329,7 +433,9 @@ static int initTerminal(int chn) AB = tgetstr("AB", &cap); Co = tgetnum("Co"); if ((NC = tgetnum("NC")) == -1) - NC = 0; + { + NC = 0; + } return 0; } @@ -337,100 +443,127 @@ static int initTerminal(int chn) init = 1; } - return 0; -} -static int cls(int chn) -{ - if (cl == (char *)0) - { - sprintf(FS_errmsgbuf, _("terminal type %s can not clear the screen"), - term); - FS_errmsg = FS_errmsgbuf; - return -1; - } - - if (mytputs(cl, 0, outc) == -1) - return -1; - - return 0; -} - -static int locate(int chn, int line, int column) -{ - termchannel = chn; - if (cm == (char *)0) - { - sprintf(FS_errmsgbuf, _("terminal type %s can not position the cursor"), - term); - FS_errmsg = FS_errmsgbuf; - return -1; - } - - if (mytputs(tgoto(cm, column - 1, line - 1), 0, outc) == -1) - return -1; - - return 0; -} - -static int colour(int chn, int foreground, int background) -{ - if (AF && AB && Co >= 8) - { - static int map[8] = { 0, 4, 2, 6, 1, 5, 3, 7 }; - - if (foreground != -1) - { - if (md && me && !(NC & 32)) - { - if (foreground > 7 && file[chn]->outforeground <= 7) - { - if (mytputs(md, 0, outc) == -1) - return -1; - /* all attributes are gone now, need to set background again */ - if (background == -1) - background = file[chn]->outbackground; - } - else if (foreground <= 7 && file[chn]->outforeground > 7) - { - if (mytputs(me, 0, outc) == -1) - return -1; - } - } - - if (mytputs(tgoto(AF, 0, map[foreground & 7]), 0, outc) == -1) - return -1; + return 0; } - if (background != -1) - { - if (mytputs(tgoto(AB, 0, map[background & 7]), 0, outc) == -1) + static int cls(int chn) + { + if (cl == (char *)0) + { + sprintf(FS_errmsgbuf, + _("terminal type %s can not clear the screen"), term); + FS_errmsg = FS_errmsgbuf; return -1; - } - } + } - return 0; -} + if (mytputs(cl, 0, outc) == -1) + { + return -1; + } -static int resetcolour(int chn) -{ - if (me) - mytputs(me, 0, outc); - if (ce) - mytputs(ce, 0, outc); + return 0; + } - return 0; -} + static int locate(int chn, int line, int column) + { + termchannel = chn; + if (cm == (char *)0) + { + sprintf(FS_errmsgbuf, + _("terminal type %s can not position the cursor"), term); + FS_errmsg = FS_errmsgbuf; + return -1; + } -static void carriage_return(int chn) -{ - if (cr) - mytputs(cr, 0, outc); - else - outc('\r'); + if (mytputs(tgoto(cm, column - 1, line - 1), 0, outc) == -1) + { + return -1; + } - outc('\n'); -} + return 0; + } + + static int colour(int chn, int foreground, int background) + { + if (AF && AB && Co >= 8) + { + static int map[8] = { 0, 4, 2, 6, 1, 5, 3, 7 }; + + if (foreground != -1) + { + if (md && me && !(NC & 32)) + { + if (foreground > 7 && file[chn]->outforeground <= 7) + { + if (mytputs(md, 0, outc) == -1) + { + return -1; + } + + /* all attributes are gone now, need to set background + * again */ + + if (background == -1) + { + background = file[chn]->outbackground; + } + } + else if (foreground <= 7 && file[chn]->outforeground > 7) + { + if (mytputs(me, 0, outc) == -1) + { + return -1; + } + } + } + + if (mytputs(tgoto(AF, 0, map[foreground & 7]), 0, outc) == -1) + { + return -1; + } + } + + if (background != -1) + { + if (mytputs(tgoto(AB, 0, map[background & 7]), 0, outc) == -1) + { + return -1; + } + } + } + + return 0; + } + + static int resetcolour(int chn) + { + if (me) + { + mytputs(me, 0, outc); + } + + if (ce) + { + mytputs(ce, 0, outc); + } + + return 0; + } + + static void carriage_return(int chn) + { + if (cr) + { + mytputs(cr, 0, outc); + } + else + { + outc('\r'); + } + + outc('\n'); + } #else static int initTerminal(int chn) @@ -485,7 +618,9 @@ static void sigintr(int sig) int FS_opendev(int chn, int infd, int outfd) { if (size(chn) == -1) - return -1; + { + return -1; + } if (file[chn] != (struct FileStream *)0) { @@ -552,11 +687,17 @@ int FS_openin(const char *name) } for (chn = 0; chn < capacity; ++chn) - if (file[chn] == (struct FileStream *)0) - break; + { + if (file[chn] == (struct FileStream *)0) + { + break; + } + } if (size(chn) == -1) - return -1; + { + return -1; + } file[chn] = malloc(sizeof(struct FileStream)); file[chn]->recLength = 1; @@ -579,7 +720,9 @@ int FS_openinChn(int chn, const char *name, int mode) mode_t fl; if (size(chn) == -1) - return -1; + { + return -1; + } if (file[chn] != (struct FileStream *)0) { @@ -589,9 +732,9 @@ int FS_openinChn(int chn, const char *name, int mode) fl = open_mode[mode]; - /* Serial devices on Linux should be opened non-blocking, otherwise the */ - /* open() may block already. Named pipes can not be opened non-blocking */ - /* in write-only mode, so first try non-blocking, then blocking. */ + /* Serial devices on Linux should be opened non-blocking, otherwise the + * open() may block already. Named pipes can not be opened non-blocking in + * write-only mode, so first try non-blocking, then blocking. */ if ((fd = open(name, fl | O_NONBLOCK)) == -1) { @@ -634,11 +777,17 @@ int FS_openout(const char *name) } for (chn = 0; chn < capacity; ++chn) - if (file[chn] == (struct FileStream *)0) - break; + { + if (file[chn] == (struct FileStream *)0) + { + break; + } + } if (size(chn) == -1) - return -1; + { + return -1; + } file[chn] = malloc(sizeof(struct FileStream)); file[chn]->recLength = 1; @@ -664,7 +813,9 @@ int FS_openoutChn(int chn, const char *name, int mode, int append) mode_t fl; if (size(chn) == -1) - return -1; + { + return -1; + } if (file[chn] != (struct FileStream *)0) { @@ -679,7 +830,7 @@ int FS_openoutChn(int chn, const char *name, int mode, int append) /* in write-only mode, so first try non-blocking, then blocking. */ fd = open(name, fl | O_CREAT | (append ? 0 : O_TRUNC) | O_NONBLOCK, 0666); - if (fd == -1) + if (fd == -1) { if (errno != ENXIO || (fd = open(name, fl | O_CREAT | (append ? 0 : O_TRUNC), 0666)) == -1) @@ -721,7 +872,9 @@ int FS_openrandomChn(int chn, const char *name, int mode, int recLength) assert(name != (const char *)0); assert(recLength > 0); if (size(chn) == -1) - return -1; + { + return -1; + } if (file[chn] != (struct FileStream *)0) { @@ -758,7 +911,9 @@ int FS_openbinaryChn(int chn, const char *name, int mode) assert(chn >= 0); assert(name != (const char *)0); if (size(chn) == -1) - return -1; + { + return -1; + } if (file[chn] != (struct FileStream *)0) { @@ -790,7 +945,9 @@ int FS_freechn(void) for (i = 0; i < capacity && file[i]; ++i); if (size(i) == -1) - return -1; + { + return -1; + } return i; } @@ -818,7 +975,9 @@ int FS_flush(int dev) return -1; } else - offset += written; + { + offset += written; + } } file[dev]->outSize = 0; @@ -838,7 +997,10 @@ int FS_close(int dev) { if (file[dev]->tty && (file[dev]->outforeground != -1 || file[dev]->outbackground != -1)) - resetcolour(dev); + { + resetcolour(dev); + } + FS_flush(dev); close(file[dev]->outfd); } @@ -856,10 +1018,14 @@ int FS_close(int dev) } if (file[dev]->tty) - tcsetattr(file[dev]->infd, TCSADRAIN, &origMode); + { + tcsetattr(file[dev]->infd, TCSADRAIN, &origMode); + } if (file[dev]->infd >= 0) - close(file[dev]->infd); + { + close(file[dev]->infd); + } free(file[dev]); file[dev] = (struct FileStream *)0; @@ -890,10 +1056,16 @@ int FS_lock(int chn, off_t offset, off_t length, int mode, int w) } if ((fd = file[chn]->infd) == -1) - if ((fd = file[chn]->outfd) == -1) - if ((fd = file[chn]->randomfd) == -1) - if ((fd = file[chn]->binaryfd) == -1) - assert(0); + { + if ((fd = file[chn]->outfd) == -1) + { + if ((fd = file[chn]->randomfd) == -1) + { + if ((fd = file[chn]->binaryfd) == -1) + assert(0); + } + } + } recordLock.l_whence = SEEK_SET; recordLock.l_start = offset; @@ -903,12 +1075,15 @@ int FS_lock(int chn, off_t offset, off_t length, int mode, int w) case FS_LOCK_SHARED: recordLock.l_type = F_RDLCK; break; + case FS_LOCK_EXCLUSIVE: recordLock.l_type = F_WRLCK; break; + case FS_LOCK_NONE: recordLock.l_type = F_UNLCK; break; + default: assert(0); } @@ -934,10 +1109,18 @@ int FS_truncate(int chn) } if ((fd = file[chn]->infd) == -1) - if ((fd = file[chn]->outfd) == -1) - if ((fd = file[chn]->randomfd) == -1) - if ((fd = file[chn]->binaryfd) == -1) - assert(0); + { + if ((fd = file[chn]->outfd) == -1) + { + if ((fd = file[chn]->randomfd) == -1) + { + if ((fd = file[chn]->binaryfd) == -1) + { + assert(0); + } + } + } + } if ((o = lseek(fd, 0, SEEK_CUR)) == (off_t) - 1 || ftruncate(fd, o + 1) == -1) { @@ -955,7 +1138,9 @@ void FS_shellmode(int dev) #endif if (file[dev]->tty) - tcsetattr(file[dev]->infd, TCSADRAIN, &origMode); + { + tcsetattr(file[dev]->infd, TCSADRAIN, &origMode); + } #if defined(CONFIG_INTERPRETER_BAS_HAVE_SIGINT) || defined(CONFIG_INTERPRETER_BAS_HAVE_SIGQUIT) interrupt.sa_flags = 0; @@ -973,7 +1158,9 @@ void FS_shellmode(int dev) void FS_fsmode(int chn) { if (file[chn]->tty) - tcsetattr(file[chn]->infd, TCSADRAIN, &rawMode); + { + tcsetattr(file[chn]->infd, TCSADRAIN, &rawMode); + } #ifdef CONFIG_INTERPRETER_BAS_HAVE_SIGINT sigaction(SIGINT, &old_sigint, (struct sigaction *)0); @@ -988,9 +1175,13 @@ void FS_xonxoff(int chn, int on) if (file[chn]->tty) { if (on) - rawMode.c_iflag |= (IXON | IXOFF); + { + rawMode.c_iflag |= (IXON | IXOFF); + } else - rawMode.c_iflag &= ~(IXON | IXOFF); + { + rawMode.c_iflag &= ~(IXON | IXOFF); + } tcsetattr(file[chn]->infd, TCSADRAIN, &rawMode); } @@ -1001,7 +1192,9 @@ int FS_put(int chn) ssize_t offset, written; if (opened(chn, 2) == -1) - return -1; + { + return -1; + } offset = 0; while (offset < file[chn]->recLength) @@ -1015,7 +1208,9 @@ int FS_put(int chn) return -1; } else - offset += written; + { + offset += written; + } } FS_errmsg = (const char *)0; @@ -1027,35 +1222,53 @@ int FS_putChar(int dev, char ch) struct FileStream *f; if (opened(dev, 0) == -1) - return -1; + { + return -1; + } f = file[dev]; if (ch == '\n') - f->outPos = 0; + { + f->outPos = 0; + } if (ch == '\b' && f->outPos) - --f->outPos; + { + --f->outPos; + } if (f->outSize + 2 >= f->outCapacity && FS_flush(dev) == -1) - return -1; + { + return -1; + } if (f->outLineWidth && f->outPos == f->outLineWidth) { if (FS_istty(dev)) - carriage_return(dev); + { + carriage_return(dev); + } else - f->outBuf[f->outSize++] = '\n'; + { + f->outBuf[f->outSize++] = '\n'; + } f->outPos = 0; } if (FS_istty(dev) && ch == '\n') - carriage_return(dev); + { + carriage_return(dev); + } else - f->outBuf[f->outSize++] = ch; + { + f->outBuf[f->outSize++] = ch; + } if (ch != '\n' && ch != '\b') - ++f->outPos; + { + ++f->outPos; + } FS_errmsg = (const char *)0; return 0; @@ -1064,8 +1277,12 @@ int FS_putChar(int dev, char ch) int FS_putChars(int dev, const char *chars) { while (*chars) - if (FS_putChar(dev, *chars++) == -1) - return -1; + { + if (FS_putChar(dev, *chars++) == -1) + { + return -1; + } + } return 0; } @@ -1076,10 +1293,16 @@ int FS_putString(int dev, const struct String *s) const char *c = s->character; while (len) - if (FS_putChar(dev, *c++) == -1) - return -1; - else - --len; + { + if (FS_putChar(dev, *c++) == -1) + { + return -1; + } + else + { + --len; + } + } return 0; } @@ -1089,11 +1312,15 @@ int FS_putItem(int dev, const struct String *s) struct FileStream *f; if (opened(dev, 0) == -1) - return -1; + { + return -1; + } f = file[dev]; if (f->outPos && f->outPos + s->length > f->outLineWidth) - FS_nextline(dev); + { + FS_nextline(dev); + } return FS_putString(dev, s); } @@ -1101,7 +1328,9 @@ int FS_putItem(int dev, const struct String *s) int FS_putbinaryString(int chn, const struct String *s) { if (opened(chn, 3) == -1) - return -1; + { + return -1; + } if (s->length && write(file[chn]->binaryfd, s->character, s->length) != s->length) @@ -1119,10 +1348,14 @@ int FS_putbinaryInteger(int chn, long int x) int i; if (opened(chn, 3) == -1) - return -1; + { + return -1; + } for (i = 0; i < sizeof(x); ++i, x >>= 8) - s[i] = (x & 0xff); + { + s[i] = (x & 0xff); + } if (write(file[chn]->binaryfd, s, sizeof(s)) != sizeof(s)) { @@ -1136,7 +1369,9 @@ int FS_putbinaryInteger(int chn, long int x) int FS_putbinaryReal(int chn, double x) { if (opened(chn, 3) == -1) - return -1; + { + return -1; + } if (write(file[chn]->binaryfd, &x, sizeof(x)) != sizeof(x)) { @@ -1152,15 +1387,21 @@ int FS_getbinaryString(int chn, struct String *s) ssize_t len; if (opened(chn, 3) == -1) - return -1; + { + return -1; + } if (s->length && (len = read(file[chn]->binaryfd, s->character, s->length)) != s->length) { if (len == -1) - FS_errmsg = strerror(errno); + { + FS_errmsg = strerror(errno); + } else - FS_errmsg = _("End of file"); + { + FS_errmsg = _("End of file"); + } return -1; } @@ -1175,21 +1416,29 @@ int FS_getbinaryInteger(int chn, long int *x) ssize_t len; if (opened(chn, 3) == -1) - return -1; + { + return -1; + } if ((len = read(file[chn]->binaryfd, s, sizeof(s))) != sizeof(s)) { if (len == -1) - FS_errmsg = strerror(errno); + { + FS_errmsg = strerror(errno); + } else - FS_errmsg = _("End of file"); + { + FS_errmsg = _("End of file"); + } return -1; } *x = (s[sizeof(x) - 1] < 0) ? -1 : 0; for (i = sizeof(s) - 1; i >= 0; --i) - *x = (*x << 8) | (s[i] & 0xff); + { + *x = (*x << 8) | (s[i] & 0xff); + } return 0; } @@ -1199,14 +1448,20 @@ int FS_getbinaryReal(int chn, double *x) ssize_t len; if (opened(chn, 3) == -1) - return -1; + { + return -1; + } if ((len = read(file[chn]->binaryfd, x, sizeof(*x))) != sizeof(*x)) { if (len == -1) - FS_errmsg = strerror(errno); + { + FS_errmsg = strerror(errno); + } else - FS_errmsg = _("End of file"); + { + FS_errmsg = _("End of file"); + } return -1; } @@ -1219,7 +1474,9 @@ int FS_nextcol(int dev) struct FileStream *f; if (opened(dev, 0) == -1) - return -1; + { + return -1; + } f = file[dev]; if (f->outPos % f->outColWidth @@ -1230,11 +1487,17 @@ int FS_nextcol(int dev) } if (!(f->outPos % f->outColWidth) && FS_putChar(dev, ' ') == -1) - return -1; + { + return -1; + } while (f->outPos % f->outColWidth) - if (FS_putChar(dev, ' ') == -1) - return -1; + { + if (FS_putChar(dev, ' ') == -1) + { + return -1; + } + } return 0; } @@ -1244,11 +1507,15 @@ int FS_nextline(int dev) struct FileStream *f; if (opened(dev, 0) == -1) - return -1; + { + return -1; + } f = file[dev]; if (f->outPos && FS_putChar(dev, '\n') == -1) - return -1; + { + return -1; + } return 0; } @@ -1258,11 +1525,17 @@ int FS_tab(int dev, int position) struct FileStream *f = file[dev]; if (f->outLineWidth && position >= f->outLineWidth) - position = f->outLineWidth - 1; + { + position = f->outLineWidth - 1; + } while (f->outPos < (position - 1)) - if (FS_putChar(dev, ' ') == -1) - return -1; + { + if (FS_putChar(dev, ' ') == -1) + { + return -1; + } + } return 0; } @@ -1270,7 +1543,9 @@ int FS_tab(int dev, int position) int FS_width(int dev, int width) { if (opened(dev, 0) == -1) - return -1; + { + return -1; + } if (width < 0) { @@ -1285,7 +1560,9 @@ int FS_width(int dev, int width) int FS_zone(int dev, int zone) { if (opened(dev, 0) == -1) - return -1; + { + return -1; + } if (zone <= 0) { @@ -1302,7 +1579,9 @@ int FS_cls(int chn) struct FileStream *f; if (opened(chn, 0) == -1) - return -1; + { + return -1; + } f = file[chn]; if (!f->tty) @@ -1312,10 +1591,14 @@ int FS_cls(int chn) } if (cls(chn) == -1) - return -1; + { + return -1; + } if (FS_flush(chn) == -1) - return -1; + { + return -1; + } f->outPos = 0; return 0; @@ -1326,7 +1609,9 @@ int FS_locate(int chn, int line, int column) struct FileStream *f; if (opened(chn, 0) == -1) - return -1; + { + return -1; + } f = file[chn]; if (!f->tty) @@ -1336,10 +1621,14 @@ int FS_locate(int chn, int line, int column) } if (locate(chn, line, column) == -1) - return -1; + { + return -1; + } if (FS_flush(chn) == -1) - return -1; + { + return -1; + } f->outPos = column - 1; return 0; @@ -1350,7 +1639,9 @@ int FS_colour(int chn, int foreground, int background) struct FileStream *f; if (opened(chn, 0) == -1) - return -1; + { + return -1; + } f = file[chn]; if (!f->tty) @@ -1360,7 +1651,9 @@ int FS_colour(int chn, int foreground, int background) } if (colour(chn, foreground, background) == -1) - return -1; + { + return -1; + } f->outforeground = foreground; f->outbackground = background; @@ -1372,11 +1665,15 @@ int FS_getChar(int dev) struct FileStream *f; if (opened(dev, 1) == -1) - return -1; + { + return -1; + } f = file[dev]; if (f->inSize == f->inCapacity && refill(dev) == -1) - return -1; + { + return -1; + } FS_errmsg = (const char *)0; if (f->inSize + 1 == f->inCapacity) @@ -1387,7 +1684,9 @@ int FS_getChar(int dev) return ch; } else - return f->inBuf[f->inSize++]; + { + return f->inBuf[f->inSize++]; + } } int FS_get(int chn) @@ -1395,7 +1694,9 @@ int FS_get(int chn) ssize_t offset, rd; if (opened(chn, 2) == -1) - return -1; + { + return -1; + } offset = 0; while (offset < file[chn]->recLength) @@ -1409,7 +1710,9 @@ int FS_get(int chn) return -1; } else - offset += rd; + { + offset += rd; + } } FS_errmsg = (const char *)0; @@ -1429,11 +1732,15 @@ int FS_inkeyChar(int dev, int ms) #endif if (opened(dev, 1) == -1) - return -1; + { + return -1; + } f = file[dev]; if (f->inSize < f->inCapacity) - return f->inBuf[f->inSize++]; + { + return f->inBuf[f->inSize++]; + } #ifdef USE_SELECT FD_ZERO(&just_infd); @@ -1448,16 +1755,19 @@ int FS_inkeyChar(int dev, int ms) len = read(f->infd, &c, 1); return (len == 1 ? c : -1); } + case 0: { FS_errmsg = (const char *)0; return -1; } + case -1: { FS_errmsg = strerror(errno); return -1; } + default: assert(0); } @@ -1506,11 +1816,15 @@ int FS_eof(int chn) struct FileStream *f; if (opened(chn, 1) == -1) - return -1; + { + return -1; + } f = file[chn]; if (f->inSize == f->inCapacity && refill(chn) == -1) - return 1; + { + return 1; + } return 0; } @@ -1521,7 +1835,9 @@ long int FS_loc(int chn) off_t cur, offset = 0; if (opened(chn, -1) == -1) - return -1; + { + return -1; + } if (file[chn]->infd != -1) { @@ -1534,9 +1850,13 @@ long int FS_loc(int chn) offset = file[chn]->outSize; } else if (file[chn]->randomfd != -1) - fd = file[chn]->randomfd; + { + fd = file[chn]->randomfd; + } else - fd = file[chn]->binaryfd; + { + fd = file[chn]->binaryfd; + } assert(fd != -1); if ((cur = lseek(fd, 0, SEEK_CUR)) == -1) @@ -1554,15 +1874,26 @@ long int FS_lof(int chn) int fd; if (opened(chn, -1) == -1) - return -1; + { + return -1; + } + if (file[chn]->infd != -1) - fd = file[chn]->infd; + { + fd = file[chn]->infd; + } else if (file[chn]->outfd != -1) - fd = file[chn]->outfd; + { + fd = file[chn]->outfd; + } else if (file[chn]->randomfd != -1) - fd = file[chn]->randomfd; + { + fd = file[chn]->randomfd; + } else - fd = file[chn]->binaryfd; + { + fd = file[chn]->binaryfd; + } assert(fd != -1); if (fstat(fd, &buf) == -1) @@ -1577,7 +1908,9 @@ long int FS_lof(int chn) long int FS_recLength(int chn) { if (opened(chn, 2) == -1) - return -1; + { + return -1; + } return file[chn]->recLength; } @@ -1595,14 +1928,18 @@ int FS_seek(int chn, long int record) if (lseek (file[chn]->randomfd, (off_t) record * file[chn]->recLength, SEEK_SET) != -1) - return 0; + { + return 0; + } FS_errmsg = strerror(errno); } else if (opened(chn, 4) != -1) { if (lseek(file[chn]->binaryfd, (off_t) record, SEEK_SET) != -1) - return 0; + { + return 0; + } FS_errmsg = strerror(errno); } @@ -1620,7 +1957,9 @@ int FS_appendToString(int chn, struct String *s, int onl) if (f->tty && f->inSize == f->inCapacity) { if (edit(chn, onl) == -1) - return (FS_errmsg ? -1 : 0); + { + return (FS_errmsg ? -1 : 0); + } } do @@ -1629,10 +1968,15 @@ int FS_appendToString(int chn, struct String *s, int onl) while (1) { if (n == f->inBuf + f->inCapacity) - break; + { + break; + } + c = *n++; if (c == '\n') - break; + { + break; + } } new = n - (f->inBuf + f->inSize); @@ -1651,7 +1995,9 @@ int FS_appendToString(int chn, struct String *s, int onl) if (*(n - 1) == '\n') { if (f->inSize == f->inCapacity) - f->inSize = f->inCapacity = 0; + { + f->inSize = f->inCapacity = 0; + } if (s->length >= 2 && s->character[s->length - 2] == '\r') { @@ -1664,7 +2010,9 @@ int FS_appendToString(int chn, struct String *s, int onl) } if ((c = FS_getChar(chn)) >= 0) - String_appendChar(s, c); + { + String_appendChar(s, c); + } if (c == '\n') { @@ -1687,8 +2035,12 @@ void FS_closefiles(void) int i; for (i = 0; i < capacity; ++i) - if (file[i] && !file[i]->dev) - FS_close(i); + { + if (file[i] && !file[i]->dev) + { + FS_close(i); + } + } } int FS_charpos(int chn)