The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/cmd-line-utils/libedit/unvis.c File Reference

mysql/src/5.1-dbg/cmd-line-utils/libedit/unvis.c File Reference

#include <config.h>
#include <sys/types.h>
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <vis.h>

Include dependency graph for unvis.c:

Go to the source code of this file.


Defines
#define	__LIBC12_SOURCE__
#define	S_GROUND 0
#define	S_START 1
#define	S_META 2
#define	S_META1 3
#define	S_CTRL 4
#define	S_OCTAL2 5
#define	S_OCTAL3 6
#define	S_HEX1 7
#define	S_HEX2 8
#define	isoctal(c) (((u_char)(c)) >= '0' && ((u_char)(c)) <= '7')
#define	xtod(c) (isdigit(c) ? (c - '0') : ((tolower(c) - 'a') + 10))
Functions
int	unvis (char cp, int c, int astate, int flag)
int	__unvis13 (char cp, int c, int astate, int flag)
int	strunvisx (char dst, const char src, int flag)
int	strunvis (char dst, const char src)

Define Documentation

#define __LIBC12_SOURCE__

Definition at line 34 of file unvis.c.

#define isoctal ( c ) (((u_char)(c)) >= '0' && ((u_char)(c)) <= '7')

Definition at line 67 of file unvis.c.

#define S_CTRL 4

Definition at line 61 of file unvis.c.

#define S_GROUND 0

Definition at line 57 of file unvis.c.

#define S_HEX1 7

Definition at line 64 of file unvis.c.

#define S_HEX2 8

Definition at line 65 of file unvis.c.

#define S_META 2

Definition at line 59 of file unvis.c.

#define S_META1 3

Definition at line 60 of file unvis.c.

#define S_OCTAL2 5

Definition at line 62 of file unvis.c.

#define S_OCTAL3 6

Definition at line 63 of file unvis.c.

#define S_START 1

Definition at line 58 of file unvis.c.

#define xtod ( c ) (isdigit(c) ? (c - '0') : ((tolower(c) - 'a') + 10))

Definition at line 68 of file unvis.c.

Function Documentation

int __unvis13	(	char *	cp,
		int	c,
		int *	astate,
		int	flag
	)

Definition at line 83 of file unvis.c.

References _DIAGASSERT, isoctal, isxdigit, NULL, S_CTRL, S_GROUND, S_HEX1, S_HEX2, S_META, S_META1, S_OCTAL2, S_OCTAL3, S_START, UNVIS_END, UNVIS_NOCHAR, UNVIS_SYNBAD, UNVIS_VALID, UNVIS_VALIDPUSH, VIS_HTTPSTYLE, and xtod.

00087 {
00088 
00089         _DIAGASSERT(cp != NULL);
00090         _DIAGASSERT(astate != NULL);
00091 
00092         if (flag & UNVIS_END) {
00093                 if (*astate == S_OCTAL2 || *astate == S_OCTAL3
00094                     || *astate == S_HEX2) {
00095                         *astate = S_GROUND;
00096                         return (UNVIS_VALID);
00097                 } 
00098                 return (*astate == S_GROUND ? UNVIS_NOCHAR : UNVIS_SYNBAD);
00099         }
00100 
00101         switch (*astate) {
00102 
00103         case S_GROUND:
00104                 *cp = 0;
00105                 if (c == '\\') {
00106                         *astate = S_START;
00107                         return (0);
00108                 } 
00109                 if ((flag & VIS_HTTPSTYLE) && c == '%') {
00110                         *astate = S_HEX1;
00111                         return (0);
00112                 }
00113                 *cp = c;
00114                 return (UNVIS_VALID);
00115 
00116         case S_START:
00117                 switch(c) {
00118                 case '\\':
00119                         *cp = c;
00120                         *astate = S_GROUND;
00121                         return (UNVIS_VALID);
00122                 case '0': case '1': case '2': case '3':
00123                 case '4': case '5': case '6': case '7':
00124                         *cp = (c - '0');
00125                         *astate = S_OCTAL2;
00126                         return (0);
00127                 case 'M':
00128                         *cp = (char)0200;
00129                         *astate = S_META;
00130                         return (0);
00131                 case '^':
00132                         *astate = S_CTRL;
00133                         return (0);
00134                 case 'n':
00135                         *cp = '\n';
00136                         *astate = S_GROUND;
00137                         return (UNVIS_VALID);
00138                 case 'r':
00139                         *cp = '\r';
00140                         *astate = S_GROUND;
00141                         return (UNVIS_VALID);
00142                 case 'b':
00143                         *cp = '\b';
00144                         *astate = S_GROUND;
00145                         return (UNVIS_VALID);
00146                 case 'a':
00147                         *cp = '\007';
00148                         *astate = S_GROUND;
00149                         return (UNVIS_VALID);
00150                 case 'v':
00151                         *cp = '\v';
00152                         *astate = S_GROUND;
00153                         return (UNVIS_VALID);
00154                 case 't':
00155                         *cp = '\t';
00156                         *astate = S_GROUND;
00157                         return (UNVIS_VALID);
00158                 case 'f':
00159                         *cp = '\f';
00160                         *astate = S_GROUND;
00161                         return (UNVIS_VALID);
00162                 case 's':
00163                         *cp = ' ';
00164                         *astate = S_GROUND;
00165                         return (UNVIS_VALID);
00166                 case 'E':
00167                         *cp = '\033';
00168                         *astate = S_GROUND;
00169                         return (UNVIS_VALID);
00170                 case '\n':
00171                         /*
00172                          * hidden newline
00173                          */
00174                         *astate = S_GROUND;
00175                         return (UNVIS_NOCHAR);
00176                 case '$':
00177                         /*
00178                          * hidden marker
00179                          */
00180                         *astate = S_GROUND;
00181                         return (UNVIS_NOCHAR);
00182                 }
00183                 *astate = S_GROUND;
00184                 return (UNVIS_SYNBAD);
00185                  
00186         case S_META:
00187                 if (c == '-')
00188                         *astate = S_META1;
00189                 else if (c == '^')
00190                         *astate = S_CTRL;
00191                 else {
00192                         *astate = S_GROUND;
00193                         return (UNVIS_SYNBAD);
00194                 }
00195                 return (0);
00196                  
00197         case S_META1:
00198                 *astate = S_GROUND;
00199                 *cp |= c;
00200                 return (UNVIS_VALID);
00201                  
00202         case S_CTRL:
00203                 if (c == '?')
00204                         *cp |= 0177;
00205                 else
00206                         *cp |= c & 037;
00207                 *astate = S_GROUND;
00208                 return (UNVIS_VALID);
00209 
00210         case S_OCTAL2:  /* second possible octal digit */
00211                 if (isoctal(c)) {
00212                         /* 
00213                          * yes - and maybe a third 
00214                          */
00215                         *cp = (*cp << 3) + (c - '0');
00216                         *astate = S_OCTAL3;     
00217                         return (0);
00218                 } 
00219                 /* 
00220                  * no - done with current sequence, push back passed char 
00221                  */
00222                 *astate = S_GROUND;
00223                 return (UNVIS_VALIDPUSH);
00224 
00225         case S_OCTAL3:  /* third possible octal digit */
00226                 *astate = S_GROUND;
00227                 if (isoctal(c)) {
00228                         *cp = (*cp << 3) + (c - '0');
00229                         return (UNVIS_VALID);
00230                 }
00231                 /*
00232                  * we were done, push back passed char
00233                  */
00234                 return (UNVIS_VALIDPUSH);
00235         case S_HEX1:
00236                 if (isxdigit(c)) {
00237                         *cp = xtod(c);
00238                         *astate = S_HEX2;
00239                         return (0);
00240                 }
00241                 /* 
00242                  * no - done with current sequence, push back passed char 
00243                  */
00244                 *astate = S_GROUND;
00245                 return (UNVIS_VALIDPUSH);
00246         case S_HEX2:
00247                 *astate = S_GROUND;
00248                 if (isxdigit(c)) {
00249                         *cp = xtod(c) | (*cp << 4);
00250                         return (UNVIS_VALID);
00251                 }
00252                 return (UNVIS_VALIDPUSH);
00253         default:        
00254                 /* 
00255                  * decoder in unknown state - (probably uninitialized) 
00256                  */
00257                 *astate = S_GROUND;
00258                 return (UNVIS_SYNBAD);
00259         }
00260 }

int strunvis	(	char *	dst,
		const char *	src
	)

Definition at line 305 of file unvis.c.

References strunvisx().

00308 {
00309         return strunvisx(dst, src, 0);
00310 }

Here is the call graph for this function:

int strunvisx	(	char *	dst,
		const char *	src,
		int	flag
	)

Definition at line 270 of file unvis.c.

References __unvis13(), _DIAGASSERT, NULL, start(), UNVIS_END, UNVIS_NOCHAR, UNVIS_VALID, and UNVIS_VALIDPUSH.

00274 {
00275         char c;
00276         char *start = dst;
00277         int state = 0;
00278 
00279         _DIAGASSERT(src != NULL);
00280         _DIAGASSERT(dst != NULL);
00281 
00282         while ((c = *src++) != '\0') {
00283         again:
00284                 switch (__unvis13(dst, c, &state, flag)) {
00285                 case UNVIS_VALID:
00286                         dst++;
00287                         break;
00288                 case UNVIS_VALIDPUSH:
00289                         dst++;
00290                         goto again;
00291                 case 0:
00292                 case UNVIS_NOCHAR:
00293                         break;
00294                 default:
00295                         return (-1);
00296                 }
00297         }
00298         if (__unvis13(dst, c, &state, UNVIS_END) == UNVIS_VALID)
00299                 dst++;
00300         *dst = '\0';
00301         return (dst - start);
00302 }

Here is the call graph for this function:

int unvis	(	char *	cp,
		int	c,
		int *	astate,
		int	flag
	)

Definition at line 71 of file unvis.c.

References __unvis13().

00075 {
00076         return __unvis13(cp, (int)c, astate, flag);
00077 }

Here is the call graph for this function:

Generated on Sat Sep 9 01:04:33 2006 for MySQL 5.1 by

1.4.7

The world's most popular open source database

mysql/src/5.1-dbg/cmd-line-utils/libedit/unvis.c File Reference

Defines

Functions

Define Documentation

Function Documentation