/ray/src/lib/tl/parsestring.cc

Go to the documentation of this file.

/*
 * lib/tl/parsestring.cc
 * 
 * Implementation of C-style string parsing for TLString::ParseString(). 
 * 
 * Copyright (c) 2004 by Klaus Sausen <nicolasius § users.sourceforge.net>
 *                   and Wolfgang Wieser ] wwieser (a) gmx <*> de [
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "tlstring.h"
#include <lib/serror.h>
#include <stdio.h>  // FIXME

TLString TLString::ParseString(const char *instr,ssize_t inlen,SError &error)
{
    if(!instr)  return TLString();
    if(inlen<0)
    {  inlen=strlen(instr);  }
    
    // Be sure that the string is NUL-terminated. Normally, that is not 
    // needed but it is better here because I'm not sure for flex...
    Assert(instr[inlen]=='\0');
    
    // No error yet; make sure success is set. 
    error.clear();
    
    // This will hold the parsed string: 
    TLString dest_str;
    // The parsed string will in no case be longer than the input; 
    // normally it will be slightly shorter, so allocating the length of 
    // the input is the best guess we have and much better than to 
    // gradually enlarge the string. 
    dest_str.d=new SData(inlen+1);   // +1 for terminating '\0'
    SData *db=dest_str.d;
    
    // Now actually parse the string. Luckily Klaus did most of it :)
    //------------------------------------------------------------------
    
    
    // d = dest; s=src
    const char *s=instr,*send=s+inlen;
    char *d=db->str;
    int8 cnt=0;
    bool quotemode=false;  // true -> treat double quotes specially
    if (*s=='"') {
        quotemode=true;
        s++;
    }
    while(s<send)
    {
        if(*s=='\\')
        {   // Handle escape sequences. 
            s++;
            switch(*s++) {
            case 'X'://interpret the next four chars as a hexnumber
                cnt+=2;
            case 'x'://interpret the next two chars as a hexnumber
            {   cnt+=2;
                int  num=0;
                bool valid=false;
                //  (plain "\x" is illegal; need at least one number) 
                do {
                    if ((*s<='9')&&(*s>='0')) {
                        num=(num<<4)|(*s-'0');
                        valid=true;
                    } else
                    if ((*s<='F')&&(*s>='A')) {
                        num=(num<<4)|(*s-'A'+0xa);
                        valid=true;
                    } else
                    if ((*s<='f')&&(*s>='a')) {
                        num=(num<<4)|(*s-'a'+0xa);
                        valid=true;
                    } else {
                        cnt=0;
                        if (!valid) { //unparsable char
                            error=SError("invalid \\x formatting",1);
                        } else  //emit byte character   
                            *d++=num;
                        if (s>=send) { //reached EOS
                            goto end_of_string;
                        }
                        break;
                    }
                    if (cnt&1) //emit byte
                        *d++=num;
                    s++;
                } while (--cnt);
            }   break;
            //this also handles "\\0"
            case '0'://interpret the next three chars as an octal num
            {   cnt+=3;
    interpret_only_two_chars:
                int num=0;
                do {    //this does *not* allow \\07 but \\007. ?? It works (WW)
                    if ((*s<='7')&&(*s>='0')) {
                        num<<=3;
                        num|=(*s++)-'0';
                    } else //escape the escape
                        cnt=1;
                } while (--cnt);
                // Not needed due to while(s<send) loop: (WW)
                // ...and would be a bug anyways for strings like "a\0377"...
                //if (s>=send)  goto end_of_string;
                if (num>>8) {  // <-- ">=256"
                    cnt=2;
                    s-=3;
                goto interpret_only_two_chars;  
                }
                *d++=num&0xff;
            }   break;
            case 't': *d++='\t'; break;
            case 'n': *d++='\n'; break;
            case 'r': *d++='\r'; break;
            case 'f': *d++='\f'; break;
            case 'v': *d++='\v'; break;
            case 'a': *d++='\a'; break;
            case 'b': *d++='\b'; break;
            case '^'://control sequence
                if ((*s<='Z')&&(*s>='A'))
                    *d++=*s-'A'+1;
                else
                    error=SError("warning: unknown ctrl char",1);
                s++;
                break;
            case '"': // escaped quote outside quotemode.. catch it
            case '\'':// escaped single quote
            case '\\'://simply copy those
                *d++=*(s-1);
                break;
            default:
                error=SError("warning: unknown escape seq",1);
                break;
            }
        }
        else    //scan for next quote and ignore any white space sequences:
        if ((quotemode)&&(*s=='"')) {
            bool fault=false;
            do {
                s++;
                switch(*s) {
                case  ' '://these whitespaces are ignored
                case '\r':
                case '\n':
                case '\t':
                case '\v':
                case '\f':
                case '\0': break;  // ignore also NULs
                case  '"':
                    ++s;  // Skip the double quote. 
                    goto quotation_starts_again;
                case '\\':  if(s[1]=='\n') break;
                default://anything else will result in an error
                    fault=true;  // We ignore it for now and scan to the 
                    break;       // opening quote first. 
                }
            } while (s<send);
quotation_starts_again:;
            if (fault) {
                error=SError("non-whitespace between string fragments",1);
            }
            // Not needed as we will run through while(s<send) immediately (WW)
            //if (s>=send)  goto end_of_string;
        } else {// The rest gets just copied. 
            *d++=*s++;
        }
    }
end_of_string:
    // Make sure that d->str[d->len]='\0'. The string must be '\0'-terminated 
    // even if there are more NULs embedded. 
    *d='\0';  // terminate
    db->len=d-db->str;
    
    //------------------------------------------------------------------
    // Done parsing. 
    
    Assert(db->len<db->asize);  // NOT <= for terminating '\0'
    Assert(db->str[db->len]=='\0');
    
    // If the parsed string is significantly smaller than the input, 
    // resize the data to free excess memory: 
    db->DownSizeIfNeeded(db->len+1);
    
    return(dest_str);
}


#if 0  /* Little test program */

#include <unistd.h>
#include <stdio.h>   /* test program */

// now try this: 
// bash# make
// bash# gcc tlstring.o -o test lib_tl.a ../lib_misc.a ../threads/lib_threads.a -lpthread
// bash# ./test "\\X5241\\x59.\\X4C41\\X554eCH();\\^M\\^J\\tandsuch"
static void DoParseString(const char *instr)
{
    SError error;
    TLString str=TLString::ParseString(instr,-1,error);
    
    fprintf(stderr,"Parsed string has length %u.\n",str.length());
    
    // This is semi-clean but OK for a test program. 
    // Using fprintf(stderr,"str: >%s<\n",str); will not play for embedded 
    // NUL characters, hence use system write(). 
    write(2,"str=>",5);
    write(2,str.str(),str.length());
    write(2,"<\n",2);
    for (uint a=0;a<str.length();a++)
        printf("%3x",(unsigned char)str.str()[a]);
    printf("\n");   
    if(error)
    {  fprintf(stderr,"Error occured: %s\n",error.msg().str());  }
}


int main(int argc,char **arg)
{
    char *s="\\X5241\\x59.\\X4C41\\X554eCH();\\^M\\^J\\tand_\\0_such";
    char*s2="\"this is the line wrapping-(\" \t \t\r\t\n \t\")-test with \\x52\\X4159\"";
    s=s2;
    if(argc==1)
    {
        printf("will parse string %s\n",s);
        DoParseString(s);
    }
    bool interactive=0;
    for(int i=1; i<argc; i++)
    {
        DoParseString(arg[i]);
        if(arg[i][0]=='-' && !arg[i][1])  interactive=1;
    }
    if(interactive)
    {
        const size_t buflen=256;
        char buf[buflen];
        while(!feof(stdin) && !ferror(stdin))
        {
            if(!fgets(buf,256,stdin)) continue;
            size_t len=strlen(buf);
            if(len && buf[len-1]=='\n')   buf[--len]='\0';
            DoParseString(buf);
        }
    }
    
    return(0);
}

#endif

---