~azzar1/unity/add-show-desktop-key : contents of trampoline/norm.c at revision 512

~azzar1/unity/add-show-desktop-key : (revision 512)

#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "norm.h"

#define SKP()               \
    do {                    \
        s++;                \
    } while (0)

#define CPY()               \
    do {                    \
        *d++ = *s++;        \
    } while (0)

#define MRK()               \
    do {                    \
        PUSH();             \
    } while (0)

#define BKP()               \
    do {                    \
        POP();              \
    } while (0)

#define BKP2()              \
    do {                    \
        POP();              \
        POP();              \
    } while (0)

#define PUSH()              \
    do {                    \
        stk[top++] = d;     \
    } while (0)

#define POP()               \
    do {                    \
        if (top == 0)       \
        {                   \
            dest[0] = '\0'; \
            return -1;      \
        }                   \
        d = stk[--top];     \
    } while (0)

/*
 * Normalize the unix pathname in src eliminating . and .. sequences
 * to yield an absolute path. Returns 0 on success, and -1 on error.
 */
int norm(char* dest, int len, const char* src)
{
    const char* s = src;
    char* d = dest;
    char* stk[256];
    int top = 0;
    enum { L0, L1, L2, L3, L4 } state = L0;
    assert(strlen(src) <= len);

    while (*s)
    {
        char c = *s;
        enum { slash, dot, other } cls;
        switch (c)
        {
            case '/':
            {
                cls = slash;
                break;
            }
            case '.':
            {
                cls = dot;
                break;
            }
            default:
            {
                cls = other;
            }
        }
        switch (state)
        {
            case L0:
            {
                switch (cls)
                {
                    case slash:
                    {
                        CPY();
                        state = L1;
                        break;
                    }
                    case dot:
                    case other:
                    {
                        dest[0] = '\0';
                        return -1;
                    }
                }
                break;
            }
            case L1:
            {
                switch (cls)
                {
                    case slash:
                    {
                        SKP();
                        break;
                    }
                    case dot:
                    {
                        MRK();
                        CPY();
                        state = L2;
                        break;
                    }
                    case other:
                    {
                        MRK();
                        CPY();
                        state = L4;
                        break;
                    }
                }
                break;
            }
            case L2:
            {
                switch (cls)
                {
                    case slash:
                    {
                        BKP();
                        state = L1;
                        break;
                    }
                    case dot:
                    {
                        CPY();
                        state = L3;
                        break;
                    }
                    case other:
                    {
                        CPY();
                        state = L4;
                        break;
                    }
                }
                break;
            }
            case L3:
            {
                switch (cls)
                {
                    case slash:
                    {
                        BKP2();
                        state = L1;
                        break;
                    }
                    case dot:
                    case other:
                    {
                        CPY();
                        state = L4;
                        break;
                    }
                }
                break;
            }
            case L4:
            {
                switch (cls)
                {
                    case slash:
                    {
                        CPY();
                        state = L1;
                        break;
                    }
                    case dot:
                    case other:
                    {
                        CPY();
                        break;
                    }
                }
                break;
            }
        }
    }
    *d = '\0';
    return 0;
}

334 by drtomc WIP only!	1	#include <assert.h>
	2	#include <string.h>
	3	#include <stdlib.h>
	4	#include <stdio.h>
	5	#include <unistd.h>
	6	#include "norm.h"
	7
335 by drtomc Log live pushdown automata! Sat down and thought, then cast the normalization	8	#define SKP() \
	9	do { \
	10	s++; \
	11	} while (0)
	12
	13	#define CPY() \
	14	do { \
	15	d++ = s++; \
	16	} while (0)
	17
	18	#define MRK() \
	19	do { \
	20	PUSH(); \
	21	} while (0)
	22
	23	#define BKP() \
	24	do { \
	25	POP(); \
	26	} while (0)
	27
	28	#define BKP2() \
	29	do { \
	30	POP(); \
	31	POP(); \
	32	} while (0)
	33
	34	#define PUSH() \
	35	do { \
	36	stk[top++] = d; \
	37	} while (0)
	38
	39	#define POP() \
	40	do { \
	41	if (top == 0) \
	42	{ \
	43	dest[0] = '\0'; \
	44	return -1; \
	45	} \
	46	d = stk[--top]; \
	47	} while (0)
334 by drtomc WIP only!	48
334 by drtomc WIP only!	49	/*
337 by drtomc Make trampoline use the path canonicalization code.	50	* Normalize the unix pathname in src eliminating . and .. sequences
	51	* to yield an absolute path. Returns 0 on success, and -1 on error.
334 by drtomc WIP only!	52	*/
	53	int norm(char* dest, int len, const char* src)
	54	{
	55	const char* s = src;
	56	char* d = dest;
335 by drtomc Log live pushdown automata! Sat down and thought, then cast the normalization	57	char* stk[256];
	58	int top = 0;
	59	enum { L0, L1, L2, L3, L4 } state = L0;
	60	assert(strlen(src) <= len);
334 by drtomc WIP only!	61
	62	while (*s)
	63	{
335 by drtomc Log live pushdown automata! Sat down and thought, then cast the normalization	64	char c = *s;
	65	enum { slash, dot, other } cls;
	66	switch (c)
	67	{
	68	case '/':
	69	{
	70	cls = slash;
	71	break;
	72	}
	73	case '.':
	74	{
	75	cls = dot;
	76	break;
	77	}
	78	default:
	79	{
	80	cls = other;
	81	}
334 by drtomc WIP only!	82	}
335 by drtomc Log live pushdown automata! Sat down and thought, then cast the normalization	83	switch (state)
334 by drtomc WIP only!	84	{
335 by drtomc Log live pushdown automata! Sat down and thought, then cast the normalization	85	case L0:
	86	{
	87	switch (cls)
	88	{
	89	case slash:
	90	{
	91	CPY();
	92	state = L1;
	93	break;
	94	}
	95	case dot:
	96	case other:
	97	{
	98	dest[0] = '\0';
	99	return -1;
	100	}
	101	}
	102	break;
	103	}
	104	case L1:
	105	{
	106	switch (cls)
	107	{
	108	case slash:
	109	{
	110	SKP();
	111	break;
	112	}
	113	case dot:
	114	{
	115	MRK();
	116	CPY();
	117	state = L2;
	118	break;
	119	}
	120	case other:
	121	{
	122	MRK();
	123	CPY();
	124	state = L4;
	125	break;
	126	}
	127	}
	128	break;
	129	}
	130	case L2:
	131	{
	132	switch (cls)
	133	{
	134	case slash:
	135	{
	136	BKP();
	137	state = L1;
	138	break;
	139	}
	140	case dot:
	141	{
	142	CPY();
	143	state = L3;
	144	break;
	145	}
	146	case other:
	147	{
	148	CPY();
149	state = L4;
150	break;
151	}
152	}
153	break;
154	}
155	case L3:
156	{
157	switch (cls)
158	{
159	case slash:
160	{
161	BKP2();
162	state = L1;
163	break;
164	}
165	case dot:
166	case other:
167	{
168	CPY();
169	state = L4;
170	break;
171	}
172	}
173	break;
174	}
175	case L4:
176	{
177	switch (cls)
178	{
179	case slash:
180	{
181	CPY();
182	state = L1;
183	break;
184	}
185	case dot:
186	case other:
187	{
188	CPY();
189	break;
190	}
191	}
192	break;
334 by drtomc WIP only!	193	}
	194	}
	195	}
	196	*d = '\0';
	197	return 0;
	198	}