//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;

/** This class provides a method for parsing the "s/.../.../" constructs
of Regex.perlCode.
@see Regex#perlCode
*/
class parsePerl {
    final static char close(char c) {
        // This switch statement does not behave
        // properly when compiled with jdk1.1.5
        // and the -O flag.
        /*
        switch(c) {
        case '[':
          return ']';
        case '(':
          return ')';
        case '{':
          return '}';
        }
        return c;*/
	if(c == '<')
	    return '>';
        if(c == '[')
            return ']';
        if(c == '(')
            return ')';
        if(c == '{')
            return '}';
        return c;
    }

    final public static String codify(String s,boolean keepbs) {
        return codify(s,0,s.length(),keepbs);
    }
    final public static String codify(String s,int i0,int iN,boolean keepbs) {
        StringBuffer sb = new StringBuffer();
        boolean ucmode = false, lcmode = false, litmode = false;
        boolean uc1 = false, lc1 = false;
        boolean modified = false;
        for(int i=i0;i<iN;i++) {
            char c = s.charAt(i);
            boolean mf = true, app=true;
            if(c=='\\') {
                app=false;
                i++;
                if(i<s.length()) {
                    char c2 = s.charAt(i);
                    switch(c2) {
                    case 'Q':
                        litmode = true;
                        break;
                    case 'U':
                        ucmode = true;
                        break;
                    case 'L':
                        lcmode = true;
                        break;
                    case 'u':
                        uc1 = true;
                        break;
                    case 'l':
                        lc1 = true;
                        break;
                    case 'E':
                        uc1=lc1=ucmode=lcmode=litmode=false;
                        break;
                    default:
                        if(keepbs)
                            sb.append('\\');
                        c=c2;
                        if(keepbs) mf = false;
                        app = true;
                        break;
                    }
                    modified |= mf;
                }
            }
            if(app) {
                if(lc1) {
                    c=lc(c);
                    lc1=false;
                } else if(uc1) {
                    c=uc(c);
                    uc1=false;
                } else if(ucmode) {
                    c=uc(c);
                } else if(lcmode) {
                    c=lc(c);
                }
                if(litmode && needbs(c))
                    sb.append('\\');
                sb.append(c);
            }
        }
        return modified ? sb.toString() : s;
    }
    final static char uc(char c) {
        return CaseMgr.toUpperCase(c);
    }
    final static char lc(char c) {
        return CaseMgr.toLowerCase(c);
    }
    final static boolean needbs(char c) {
        if(c >= 'a' && c <= 'z')
            return false;
        if(c >= 'A' && c <= 'Z')
            return false;
        if(c >= '0' && c <= '9')
            return false;
        if(c == '_')
            return false;
        return true;
    }
    final static Regex parse(String s) {
        boolean igncase = false, optim = false, gFlag = false;
        boolean sFlag = false, mFlag = false, xFlag = false;

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        int i=0,count=0;
        char mode,delim='/',cdelim='/';
        if(s.length() >= 3 && s.charAt(0)=='s') {
            mode = 's';
            delim = s.charAt(1);
            cdelim = close(delim);
            i=2;
        } else if(s.length() >= 2 && s.charAt(0)=='m') {
            mode = 'm';
            delim = s.charAt(1);
            cdelim = close(delim);
            i=2;
        } else if(s.length() >= 1 && s.charAt(0)=='/') {
            mode = 'm';
            i=1;
        } else {
            try {
                RegSyntaxError.endItAll(
		    "Regex.perlCode should be of the "+
                    "form s/// or m// or //");
            } catch(RegSyntax rs) {}
            return null;
        }
        for(;i<s.length();i++) {
            if(s.charAt(i)=='\\') {
                s1.append('\\');
                i++;
            } else if(s.charAt(i)==cdelim && count==0) {
                i++;
                break;
            } else if(s.charAt(i)==delim && cdelim != delim) {
                count++;
            } else if(s.charAt(i)==cdelim && cdelim != delim) {
                count--;
            }
            s1.append(s.charAt(i));
        }
        if(mode=='s' && cdelim != delim) {
            while(i<s.length() && Prop.isWhite(s.charAt(i)) )
                i++;
            if(i>=s.length()) {
                try {
                    RegSyntaxError.endItAll(""+mode+delim+" needs "+cdelim);
                } catch(RegSyntax rs) {}
                return null;
            }
            cdelim = close(delim = s.charAt(i));
            i++;
        }
        count=0;
        if(mode=='s') {
            for(;i<s.length();i++) {
                if(s.charAt(i)=='\\') {
                    s2.append('\\');
                    i++;
                } else if(s.charAt(i)==cdelim && count==0) {
                    i++;
                    break;
                } else if(s.charAt(i)==delim && cdelim != delim) {
                    count++;
                } else if(s.charAt(i)==cdelim && cdelim != delim) {
                    count--;
                }
                s2.append(s.charAt(i));
            }
        }
        for(;i<s.length();i++) {
            char c = s.charAt(i);
            switch(c) {
	    case 'x':
	        xFlag = true;
		break;
            case 'i':
                igncase = true;
                break;
            case 'o':
                optim = true;
                break;
            case 's':
                sFlag = true;
                break;
            case 'm':
		mFlag = true;
                break;
            case 'g':
                gFlag = true;
                break;
            default:
                // syntax error!
                try {
                    RegSyntaxError.endItAll("Illegal flag to pattern: "+c);
                } catch(RegSyntax rs) {}
                return null;
            }
        }
        Regex r = new Regex();
        try {
            String pat=s1.toString(),reprul=s2.toString();
	    if(xFlag) {
	      pat = strip(pat);
	      reprul = strip(reprul);
	    }
            r.compile(pat);
            r.ignoreCase |= igncase;
            r.gFlag |= gFlag;
            r.sFlag |= sFlag;
	    r.mFlag |= mFlag;
            if(optim) r.optimize();
	    if(delim=='\'')
              r.setReplaceRule(new StringRule(reprul));
	    else
              r.setReplaceRule(ReplaceRule.perlCode(reprul));
        } catch(RegSyntax rs) {
            r = null;
        }
        return r;
    }
    static String strip(String s) {
      StringBuffer sb = new StringBuffer();
      for(int i=0;i<s.length();i++) {
        char c = s.charAt(i);
	if(Prop.isWhite(c)) {
	  ;
	} else if(c == '#') {
	  i++;
	  while(i<s.length()) {
	    if(s.charAt(i) == '\n')
	      break;
	    i++;
	  }
        } else if(c == '\\') {
	  sb.append(c);
	  sb.append(s.charAt(++i));
	} else
	  sb.append(c);
      }
      return sb.toString();
    }
}