// $Author: Thomas Stolwijk $
// $Date: 2006/12/11 00:00:00 $
// $Revision: 1.0 $
/*global UNIFACE document dojo dijit */

UNIFACE.namespace("syn").extend(
// This anonymous function enables use of PRIVATE namespace members
function(){

    /* internal applet representation for wildcard characters */
    var PROFILE = {
        WILD      : { "INT": "\u0010", "INTRE": /\u0010/g, "EXT": "*", "RE": /\*/g, "ERE":   /\\\*/g },
        WILD1     : { "INT": "\u0011", "INTRE": /\u0011/g, "EXT": "?", "RE": /\?/g, "ERE":   /\\\?/g },
        EQUAL     : { "INT": "\u0012", "INTRE": /\u0012/g, "EXT": "=", "RE": /\=/g, "ERE":   /\\=/g  },
        GREATER   : { "INT": "\u0013", "INTRE": /\u0013/g, "EXT": ">", "RE":  />/g, "ERE":   /\\>/g  },
        LESS      : { "INT": "\u0014", "INTRE": /\u0014/g, "EXT": "<", "RE":  /</g, "ERE":   /\\</g  },
        NOT       : { "INT": "\u0015", "INTRE": /\u0015/g, "EXT": "!", "RE":  /!/g, "ERE":   /\\!/g  },
        AND       : { "INT": "\u0016", "INTRE": /\u0016/g, "EXT": "&", "RE":  /&/g, "ERE":   /\\&/g  },
        OR        : { "INT": "\u0017", "INTRE": /\u0017/g, "EXT": "|", "RE": /\|/g, "ERE":   /\\\|/g },
        SEP       : { "INT": "\u001b", "INTRE": /\u001b/g, "EXT": ";", "RE":  /;/g, "ERE":   /\\;/g }
    };
    
    var SEPARATORS = [ PROFILE.EQUAL, PROFILE.GREATER, PROFILE.LESS, PROFILE.NOT, PROFILE.AND, PROFILE.OR, PROFILE.SEP ];
    var SEPARATOR = [ PROFILE.SEP ];
    var PROFILECHARS = [ PROFILE.EQUAL, PROFILE.GREATER, PROFILE.LESS, PROFILE.NOT, PROFILE.AND, PROFILE.OR ];
    var WILDCARDS = [ PROFILE.WILD, PROFILE.WILD1 ];
    var ESCAPABLES = [ PROFILE.EQUAL, PROFILE.GREATER, PROFILE.LESS, PROFILE.NOT, PROFILE.AND, PROFILE.OR, PROFILE.WILD, PROFILE.WILD1 ];
    
function concatChars(a_profileChars, a_intorExt)
{
    var i;
    var l_concat="";
    
    for (i in a_profileChars) if (a_profileChars.hasOwnProperty(i))
    {
        if (typeof a_profileChars[i][a_intorExt] == "string")
        {
            l_concat += a_profileChars[i][a_intorExt];
        }
        else
        {
            l_concat += a_profileChars[i][a_intorExt].source;
        }
        
    }
    return l_concat;
}    

function profileRegex(a_profileChars, a_intorExt)
{
    return new RegExp("[" + concatChars(a_profileChars, a_intorExt)+ "]");
}

var EVENSLASHES = "(^|[^\\\\])(\\\\\\\\)*";
var INTERNALSEPARATORS = new RegExp( "()()([" + concatChars(SEPARATORS, "INT") + "])");
var EXTERNALSEPARATORS = new RegExp( EVENSLASHES + "(\\\\[" + concatChars(SEPARATORS, "RE") + "])");
var INTERNALSEPARATOR = new RegExp( "()()([" + concatChars(SEPARATOR, "INT") + "])");
var EXTERNALSEPARATOR = new RegExp( EVENSLASHES + "(\\\\[" + concatChars(SEPARATOR, "RE") + "])");
var ESCAPES = new RegExp("\\\\(?=[" + concatChars(ESCAPABLES, "RE") + "])", "g");
var NOESCAPES = new RegExp("(?=[" + concatChars(ESCAPABLES, "RE") + "])", "g");
var SWAPPEDSEPARATORS = new RegExp( EVENSLASHES + "([" + concatChars(SEPARATORS, "RE") + "])");
var SWAPPEDSEPARATOR = new RegExp( EVENSLASHES + "([" + concatChars(SEPARATOR, "RE") + "])");

var WILDRE     = profileRegex(WILDCARDS, "INT");
/*
external (WEB/escaped) rep to Internal (UNIFACE) rep
*/
function ext2int(a_string, aSwapProfile)
{
    if (aSwapProfile == undefined) // pragma(allow-loose-compare)
    {
        aSwapProfile = "ERE";
    }
    var p;
    var l_subE = a_string.split(/\\\\/);
    var i;
    var l_res = "";
    for (i=0; i<l_subE.length; i++)
    {
        var l_sub = l_subE[i];
        for (p in ESCAPABLES) if (ESCAPABLES.hasOwnProperty(p))
        {
            l_sub = l_sub.replace(ESCAPABLES[p][aSwapProfile], ESCAPABLES[p].INT);
        }
        // Remove ESCAPES if we're swapped
        if (aSwapProfile==="RE")
        {
            l_sub = l_sub.replace(ESCAPES, "");
        }        
        if (l_res)
        {
            l_res += "\\";  
        }
        l_res += l_sub;
    }
    return l_res;
}

/* 
internal to external (WEB/Escaped)
*/
function int2ext(a_string, aSwapProfile)
{
    a_string = a_string.replace(/\\/g, "\\\\");
    if (aSwapProfile)
    {
        a_string = a_string.replace(NOESCAPES, "\\");
    }
    var p;
    for (p in ESCAPABLES) if (ESCAPABLES.hasOwnProperty(p))
    {
        a_string = a_string.replace(ESCAPABLES[p].INTRE, aSwapProfile ? "" : "\\" + ESCAPABLES[p].EXT);
    }
    return a_string;
}

function getSubFields(a_field, a_intOrExtOrSwap)
{
    if (a_intOrExtOrSwap == null) /* pragma(allow-loose-compare) */
    {
        a_intOrExtOrSwap = INTERNALSEPARATORS;
    }
    var l_subFields=[];
    var l_sfs = UNIFACE.splitString(a_field, a_intOrExtOrSwap);
    var l_idx ;

    for (l_idx = 0; l_idx<l_sfs.length; l_idx += 4)
    {
        var l_ob;
        if (l_sfs[l_idx+1] === undefined)
        {
            l_ob = { val : l_sfs[l_idx], profile :  "" };
        }
        else
        {
            l_ob = { val : l_sfs[l_idx] + l_sfs[l_idx+1] + l_sfs[l_idx+2], profile :  l_sfs[l_idx+3] };
        }
        l_subFields.push(l_ob);
    }
    return l_subFields;
}

function mergeSubFields(a_fields)
{
    var l_idx;
    var l_res="";

    for (l_idx = 0; l_idx<a_fields.length; l_idx++)
    {
        l_res += a_fields[l_idx].val + a_fields[l_idx].profile;
    }
    return l_res;
}

function format2regex(entryFormat)
{
    // Implementation 1: home-grown loop
    var j;
    var l_reText="";

    for (j=0; j< entryFormat.length; j++)
    {
        // 1. Special chars
        switch(entryFormat.charAt(j))
        {
            case '~':
                switch (entryFormat.charAt(j+1))
                {
                    case '&':
                        l_reText += "[A-Za-z\\u0080-\\uFFFF]"; 
                        j++;
                        break;   
                    case '@':
                        l_reText += "[\\w\\u0080-\\uFFFF]";    
                        j++;
                        break;
                }
                continue;
            case '%':
                // Escaped: treat next char as literal
                switch (entryFormat.charAt(j+1))
                {
                    case '%':
                        if (entryFormat.charAt(j+1)==="^")
                        {
                            l_reText += "(\\n|\\r|\\r\\n)";
                            j+=2;
                            
                        } 
                        else
                        {
                            l_reText += entryFormat.charAt(j+1); 
                            j++;
                        }
                        break;
                    case '(':
                    case ')':
                    case '*':
                    case '?':
                        l_reText += "\\"; /* pragma(fallthrough) */
                    case '@':
                    case '&':
                    case '#':
                        l_reText += entryFormat.charAt(j+1); 
                        j++;
                }
                break;                
            case '(':
                l_reText += "(";
                continue;
            case ')':
                l_reText += ")?";    
                continue;
            case '#':
                l_reText += "[0-9]";
                continue;
            case '&':
                l_reText += "[A-Za-z]";
                continue;            
            case '@':
                l_reText += "\\w";
                continue;            
            case '*':
                switch (entryFormat.charAt(j-1))
                {
                    case '&':
                    case '#':
                    case '?':
                    case '@':
                        l_reText += "*";
                        break;
                     default:
                        l_reText += ".*";
                        break;
                }
                continue;   
            case '?':
                l_reText += ".";
                continue;   
            case '[':
            case ']':
            case '.':
            case '\\':
            case '^':
            case '$':
            case '+':
            case '|':
            case '{':
            case '}':
                l_reText += "\\";  /* pragma(fallthrough) */
            default:
               l_reText += entryFormat.charAt(j);
                                       
        }
    }
    
    return new RegExp("^" + l_reText + "$");
}

function checkNumeric(subfld, scale)
{
    var output = subfld.newValue;
    // No check if there are wildcards....
    if (!output.match(WILDRE))
    {
        // 1. Prepare for match: make decimal separator a dot, remove thousand separators
        var l_sep = ".";
        if (subfld.syntax.DIS != undefined) /* pragma(allow-loose-compare) */
        {
            if (subfld.syntax.DIS.charAt(0)==="N")
            {
                if (subfld.syntax.DIS.charAt(1)===",")
                {
                    output = output.replace(/\./g,"").replace(/,/g,".");
                    l_sep = ",";
                }
            }
        }
        output = output.replace(/,/g,"");
        
        // 2. Check
        var lNumRe = /^\s*(\+|-)?0*([0-9]+)(\.([0-9]+))?((e|E)(\+|-)?([0-9]+))?(\+|-)?\s*$/;
        var l_num = output.match(lNumRe);
        if (!l_num)
        {
            throw new UNIFACE.syn.SyntaxError("0123", subfld.fieldName);
        }
        // 3. Normalize
        //var l_num = 
        // sign: $1, mant: $2 (.) $4 , exp sign: $7, exp: $8
        var l_sign = l_num[1] ? l_num[1] : "",
            l_whole = l_num[2] ? l_num[2] : "0",
            l_dec  = l_num[4] ? l_num[4].replace(/(^0)?0*$/,"$1") : "", // remove trailing spaces from decimal portion
            l_expsign = l_num[7] ? l_num[7] : "",
            l_exp = l_num[8] ? l_num[8] : "";
       
        var exp = parseInt(l_num[7]+"0"+l_num[8],10);
        
        // 4. Round in the Uniface way....
        if (scale != undefined) /* pragma(allow-loose-compare) */
        {
            var l_scale = parseInt(scale,10);
            var l_decimals = l_dec.length - exp;
            if (l_decimals > l_scale)
            {
                var l_mant = l_whole+l_dec;
                var l_newNum = "";
                
                var l_pos = l_mant.length - l_decimals + l_scale;
                if (l_pos >= 0  )
                {
                    var i;
                    var l_c;
                    if (l_mant.charAt(l_pos) >='5')
                    {
                        while(l_pos >=0 )
                        {
                            if (l_pos === 0)
                            {
                               l_newNum = "1" + l_newNum;
                            }
                            else 
                            {
                                l_c = l_mant.charAt(l_pos-1);
                                if (l_c === "9")
                                {
                                    l_newNum = "0" + l_newNum;

                                }
                                else
                                {
                                    l_newNum = (parseInt(l_c,10)+1).toString() + l_newNum;
                                    l_pos--;
                                    break;
                                }
                            }
                            l_pos--;
                        }       
                    }                             
                    if (l_pos >=0)
                    {
                        l_newNum = l_mant.slice(0,l_pos) + l_newNum;
                    }
                    for (l_pos = l_mant.length - l_decimals + l_scale; l_pos < l_mant.length; l_pos++)
                    {
                        l_newNum += "0";
                    }
                    l_whole = l_newNum.substr(0, l_newNum.length - l_dec.length);
                    l_dec = l_newNum.substr(l_newNum.length - l_dec.length);
                    
                }
                else // l_pos <0
                {
                    subfld.newValue = 0;
                    return;                               
                }                              
            }
        }
        
        // 5. Create new representation                                                    
        subfld.newValue = (l_sign==="-" ? "-" : "");
        subfld.newValue +=l_whole;
        if (l_dec)
        { 
            subfld.newValue += l_sep + l_dec;
        }
        if (l_exp)
        {
            subfld.newValue += "e" + (l_expsign==="-" ? "-" : "+") + l_exp;
        }
    }
}

var datatypechecks = {
    "N" : function (subfld)
    {
        return checkNumeric(subfld, subfld.syntax.SCALE);
    },
    "S" : function (subfld, special)
    {
        if (!special && subfld.newValue.match(/[\u0100-\u058f\u0600-\uFF64\uFF9F-\uFFFF]/))
        {
            throw new UNIFACE.syn.SyntaxError("0131", subfld.fieldName);
        }
    },
    "F" : checkNumeric
     /*               {
                    }

                    else if (datatype.equals("D") || datatype.equals("d")) 
                    {
                        displayFormat  = syntaxset.getShorthandStringValue("DIS", "dd-mmm-yyyy"); 
                        entryFormat    = syntaxset.getShorthandStringValue("ENT"); 
                        centuryBreak   = syntaxset.getShorthandStringValue("CENTBR"); // get century break
                        checkdatetime checkDateTime = new checkdatetime(datatype, subFieldValue, displayFormat, entryFormat, toDay);
                        checkDateTime.setCenturyBreak(centuryBreak);
                        output = checkDateTime.check();
                    }
                    else if (datatype.equals("T") || datatype.equals("t"))
                    {
                        displayFormat  = syntaxset.getShorthandStringValue("DIS", "hh:nn:ss");
                        entryFormat    = syntaxset.getShorthandStringValue("ENT"); 
                        checkdatetime checkDateTime = new checkdatetime(datatype, subFieldValue, displayFormat, entryFormat, toDay);
                        output = checkDateTime.check();
                    }
                    else if (datatype.equals("E") || datatype.equals("e")) 
                    {
                        displayFormat  = syntaxset.getShorthandStringValue("DIS", "dd-mmm-yy hh:nn:ss");
                        entryFormat    = syntaxset.getShorthandStringValue("ENT"); 
                        centuryBreak   = syntaxset.getShorthandStringValue("CENTBR"); // get century break
                        checkdatetime checkDateTime = new checkdatetime(datatype, subFieldValue, displayFormat, entryFormat, toDay);
                        checkDateTime.setCenturyBreak(centuryBreak);
                        output = checkDateTime.check();
                    }    */
};

var subfieldChecks = {
   "DATTYP" :  function(shorthand, subfld)   {
                var lDataType = ("" + shorthand).toUpperCase();
                
                var special = false;
                var output = "";

                if (lDataType.length == 2)
                {
                    lDataType = lDataType.charAt(1);
                    special = true;
                }
                // datatype checking
                // numeric, float, date, time, datetime
                var subFieldValue = subfld.newValue;
                if (subFieldValue.length > 0) // datatype checking only required if there is a value 
                {
                    output = subFieldValue;
                    var l_check = datatypechecks[lDataType];
                    if (l_check !== undefined)
                    {
                        l_check(subfld, special);
                    }
                }
            },
        "WIDTYP": function(shorthand, subfld)  {
                var sV = subfld.newValue;
                if (sV.length > 0 && !sV.match(WILDRE) && subfld.valrep !== undefined && subfld.valrep[sV] === undefined)
                {
                    throw new UNIFACE.syn.SyntaxError("0119", subfld.fieldName);
                }
            },
        "ENT":function handleShorthandEnt( shorthand,  subfld)  {
                var subFieldValue = subfld.newValue;
                
                var datatype = subfld.syntax.DATTYP;//set.getShorthandDatatype(); 
                if (datatype.length == 2)
                {
                    datatype = datatype.charAt(1);
                }
                
                if (datatype==="S") // only perform entry format checking for string fields @pr08
                {
                    if (subfld.syntax.ENT_regex === undefined) 
                    {
                        subfld.syntax.ENT_regex  = format2regex(shorthand);
                    }
                    var l_regEx =  subfld.syntax.ENT_regex;
                    if (l_regEx && !subFieldValue.match(l_regEx))
                    {
                        throw new UNIFACE.syn.SyntaxError("0126", subfld.fieldName);                        
                    }
                }
            },
        "LEN": function (shorthand, subfld)   {
        
                var len=0;
                var subFieldValue = subfld.newValue;
                len = subFieldValue.length; 
                if (!subFieldValue.match(WILDRE) && len > 0 && len < shorthand.min)
                {
                    //syntaxexception.setParam(fieldname.getFld());
                    throw new UNIFACE.syn.SyntaxError("0121", subfld.fieldName);
                }
                if (len > shorthand.max)
                {
                    //syntaxexception.setParam(fieldname.getFld());
                    throw new UNIFACE.syn.SyntaxError("0120", subfld.fieldName);
                }
            },
        "BRM": function( shorthand,  subfld) {
                var l_len1 = subfld.newValue.match(/[\[\{\(]/g);
                if (l_len1 !== null)
                {
                    l_len1 = l_len1.length;
                }
                var l_len2 = subfld.newValue.match(/[\]\}\)]/g);
                if (l_len2 !== null)
                {
                    l_len2 = l_len2.length;
                }
                
                if (l_len1 !== l_len2)
                {
                    throw new UNIFACE.syn.SyntaxError("0137", subfld.fieldName);
                }
            },
        "DIG": function (shorthand, subfld) {
                // allow spaces
                
                if (subfld.newValue.match(new RegExp("[^" + concatChars(WILDCARDS, "RE") + "0-9 ]") ))
                {
                    throw new UNIFACE.syn.SyntaxError("0123", subfld.fieldName);
                }
            },
        "NUM": function( shorthand, subfld)   {
                if (subfld.newValue.match(new RegExp("[^," + concatChars(WILDCARDS, "RE") + "0-9\\.\\-+ ]") ))
                {
                    throw new UNIFACE.syn.SyntaxError("0123", subfld.fieldName);
                }
            },
        "ASC": function(shorthand,  subfld)   {
                var subFieldValue = subfld.newValue;
                //syntaxdebug.writeDebug(2, "ASC");
                var i;
                for (i = 0; i < subFieldValue.length; i++)
                {
                    if (subFieldValue.charCodeAt(i) > 0x007F)
                    {
                        throw new UNIFACE.syn.SyntaxError("0131", subfld.fieldName);
                    }
                }
            },
        "MUL":  function( shorthand,  subfld) 
            {
                var subFieldValue = subfld.newValue;
                var i;
                for ( i = 0; i < subFieldValue.length; i++)
                {  // @PR24
                    if (subFieldValue.charAt(i) > '\u00FF')
                    {
                        throw new UNIFACE.syn.SyntaxError("0131", subfld.fieldName);
                    }
                }
            },
        "MINVAL": function( shorthand,  subfld) 
            {
                var l_actNum = parseFloat(subfld.newValue);
                var l_min = parseFloat(shorthand.min);
                if (!isNaN(l_min) && !isNaN(l_actNum))
                {
                    if (l_actNum < l_min)
                    {
                        throw new UNIFACE.syn.SyntaxError("0121", subfld.fieldName);
                    }
                }
            },
        "MAXVAL": function( shorthand,  subfld)
            {
                var l_actNum = parseFloat(subfld.newValue);
                var l_max = parseFloat(shorthand.min);
                if (!isNaN(l_max) && !isNaN(l_actNum))
                {
                    if (l_max < l_actNum )
                    {
                        throw new UNIFACE.syn.SyntaxError("0120", subfld.fieldName);
                    }
                }
            },
        "LOW": function( shorthand,  subfld)  {
                subfld.newValue = subfld.newValue.replace(/[A-Z]/g, function($1) { return $1.toLowerCase(); } );
            },  
        "UPC": function( shorthand,  subfld)  {
                subfld.newValue = subfld.newValue.replace(/[a-z]/g, function($1) { return $1.toUpperCase(); } );
            },  
        "RCS": function( shorthand,  subfld)    {
                subfld.newValue = subfld.newValue.replace(/([ \t])[ \t]+/g, "$1");
            },
        "DLS": function( shorthand,  subfld)   {
                subfld.newValue = subfld.newValue.replace(/^[ \t]*/, "");
            },
        "DLZ": function ( shorthand,  subfld)
            {
                subfld.newValue = subfld.newValue.replace(/^0*/, "");
            }
        };
        
   var wholeFieldChecks = {
   /*            
       // toDay is used to be able to use an other date in testscripts (for example to be able
    // to test Y2K testcases)
    // using this feature it is possible to set an other date in stead of today during testing
    // it is implemented using a special TODAY(29022000) syntax mnemonic (only allowed when testing)
    //private static Date toDay = new Date();                                         // @pr01 @pr09
         "TODAY": function(shorthand)
            {
                Date setDate;
                int year, month, day;
                String newDate = shorthand.getValue(); // set a new date as today
                if (!syntaxdebug.inDebugMode()) // test to see if this applet is in debugmode
                {
                    //syntaxexception.setParam("Internal error: Shorthand Syntax Error: TODAY");
                    throw new UNIFACE.syn.SyntaxError("0000", fieldVal.fieldName);
                }
                try
                {
                    syntaxdebug.writeDebug(2, "TODAY [" + shorthand.getValue() + "]");
                    year  = Integer.valueOf(newDate.substring(4, 8)).intValue() - 1900;     // years since 1900
                    month = Integer.valueOf(newDate.substring(2, 4)).intValue() - 1;        // month 0-11
                    day   = Integer.valueOf(newDate.substring(0, 2)).intValue();            // day of month 1-31
                    setDate = new Date(year, month, day);
                    toDay = setDate;
                    syntaxdebug.writeDebug(4, "new date2 [" + toDay + "]");
                }
                catch(NumberFormatException e)
                {
                    //syntaxexception.setParam("Internal error: Shorthand Syntax Error: TODAY(" + newDate + ")");
                    throw new UNIFACE.syn.SyntaxError("0000", fieldVal.fieldName);
                }
            },  */
        "NED":function ( shorthand, fieldVal)    {
                if (fieldVal.fieldValue !== fieldVal.originalValue)
                {
                    throw new UNIFACE.syn.SyntaxError("0104", fieldVal.fieldName);
                }  
             }, 
        "NEDKEY": function(shorthand, fieldVal) 
            {
                if (fieldVal.fieldValue !== fieldVal.originalValue)
                {
                    throw new UNIFACE.syn.SyntaxError("0105", fieldVal.fieldName);
                }
            },
        "DIM": function( shorthand, fieldVal)
            {
                if (fieldVal.fieldValue !== fieldVal.originalValue)
                {
                    throw new UNIFACE.syn.SyntaxError("0104", fieldVal.fieldName);
                }
            },
        "MAN": function(shorthand, fieldVal)
            {
                var i;
                for (i = 0; i<fieldVal.subfields.length; i++)
                {
                    if (fieldVal.subfields[i].val.length > 0)
                    {
                        return;
                    }
                }
                throw new UNIFACE.syn.SyntaxError("0129", fieldVal.fieldName);
            }
    };
    
return { // Export PUBLIC members of the namespace
    int2ext : function(a_syntax, a_fieldValue)
    {
        if (!a_syntax.NGLD) /* pragma(allow-loose-compare) */
        {
            return  int2ext(a_fieldValue, (a_syntax.SWAPGP != undefined && a_syntax.SWAPGP) );/* pragma(allow-loose-compare) */
        }
        return a_fieldValue;
    },
    checkField : function(a_syntax, a_fieldValue, a_originalValue, a_valrep, a_fieldName)
    {
        var a_shortHand;
        var l_newValue;
        var l_PROF = "ERE";
        if (a_syntax.SWAPGP != undefined && a_syntax.SWAPGP) /* pragma(allow-loose-compare) */
        {
            l_PROF = "RE";
        }
        if (a_syntax.NGLD) /* pragma(allow-loose-comp689are) */
        {
            l_newValue = a_fieldValue;
        }
        else
        {
            l_newValue = ext2int(a_fieldValue, l_PROF);
        }
            
        var l_fieldValue = {
            originalValue : a_originalValue,
            fieldValue : a_fieldValue,
            newValue : l_newValue,
            normalizedValue : l_newValue,
            syntax : a_syntax,
            valrep : a_valrep,
            fieldName : a_fieldName,
            error : null
        };
        
        try
        {
            var l_subFields;
            if (a_syntax.NGLD)
            {
                l_subFields =  getSubFields(l_fieldValue.newValue, INTERNALSEPARATOR);
            }
            else
            {
                l_subFields = getSubFields(l_fieldValue.newValue);
            }
                    
            l_fieldValue.subfields = l_subFields;
            for (a_shortHand in a_syntax)
            {
               if (wholeFieldChecks[a_shortHand] != undefined) /* pragma(allow-loose-compare) */
               {
                   wholeFieldChecks[a_shortHand](a_syntax[a_shortHand], l_fieldValue );
               }
            }
            
            var l_subFieldValue = 
                    { 
                        syntax : a_syntax,
                        valrep : a_valrep,
                        originalValue : "",
                        fieldName : a_fieldName,
                        error: null
                    };            
            var l_sfIdx;
            for (l_sfIdx = 0; l_sfIdx < l_subFields.length; l_sfIdx++)
            {
                l_subFieldValue.fieldValue = l_subFields[l_sfIdx].val;
                l_subFieldValue.newValue = l_subFieldValue.fieldValue;
                
                for (a_shortHand in a_syntax)
                {
                   if (subfieldChecks[a_shortHand] != undefined) /* pragma(allow-loose-compare) */
                   {
                       subfieldChecks[a_shortHand](a_syntax[a_shortHand], l_subFieldValue );
                   }
                }
                // subfieldChecks.WIDTYP(a_syntax.WIDTYP, l_subFieldValue );
                l_subFields[l_sfIdx].val = l_subFieldValue.newValue;
            }
            l_fieldValue.normalizedValue = mergeSubFields(l_subFields);
            if (a_syntax.NGLD)
            {
                l_fieldValue.newValue = l_fieldValue.normalizedValue;
            }
            else
            {
                l_fieldValue.newValue = int2ext(l_fieldValue.normalizedValue, (a_syntax.SWAPGP != undefined && a_syntax.SWAPGP) );/* pragma(allow-loose-compare) */
            }
        }
        catch (e)
        {
            if (e instanceof UNIFACE.syn.SyntaxError)
            {
                l_fieldValue.error = e;
            }
            else
            {
                UNIFACE.throwException(e);
            }
        }
        return l_fieldValue;        
    },
    SyntaxError : function(a_code)
    {
        this.exceptionCode = a_code;
    }
}; // return 

}() // Immediately call anonymous function

);

(function()
{
var uMessages = {
"0104" : "A mező nem szerkeszthető/Field is display only.",
"0105" : "Not allowed to change primary key field.",
"0119" : "Nem megengedett érték/Illegal ValRep value.",
"0120" : "Túl hosszú kitöltés/Subfield too large.",
"0121" : "Túl rövid kitöltés/Subfield too small.",
"0123" : "Csak számok adhatók meg/Illegal format for Numeric field.",
"0124" : "A dátum formátum éééé-hh-nn/Date format is yyyy-mm-dd.",
"0125" : "Az idő formátum óó:pp/Time format is hh:mm.",
"0126" : "Hibás adatformátum/Illegal syntax format.",
"0127" : "Hibás formátum/Illegal entry format.",
"0129" : "Kötelező a mező kitöltése/Subfield(s) are required.",
"0130" : "Túl hosszú kitöltés/Too many subfields specified.",
"0131" : "Nem megengedett karakter(ek)/One or more characters not found in character set.",
"0132" : "Nem szám/Illegal numeric.",
"0137" : "Open/close brackets do not match.",
"0138" : "Illegal format for floating field."
};


UNIFACE.syn.SyntaxError.prototype.toString = function() {
    return uMessages[this.exceptionCode];
};

})();