//******************************************************************************
// * 関数名		：文字の種類チェック
// * 関数 ID		：checkCharTypeA (String val, Array checkList, String mode)
// * 処理内容		：文字の種類チェックする
// * 書式		：blnRet =iCheck.checkCharType(val, checkList, mode);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： typeのリスト
// *                                  mode       ： Permit or prohibit
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkCharTypeA( val, checkList, mode ) {



	// set initial return value
	var found = true ;

	// check every character of input value
	for (i = 0; i < val.length; i++) {

		// all the character  type
		for (j = 0; j < checkList.length; j++) {

			// set temporary initially value
			var tempFound = false;

			// 全角文字
			if (checkList[j] == "fw-all") {

				// permit の場合
				if( mode == "permit" ) {

					// call 全角文字function _all
					found = checkFwAll_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 全角文字function  _none
					found = checkFwAll_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角文字
			} else if (checkList[j] == "hw-all") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角文字function _all
					found = checkHwAll_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角文字function  _none
					found = checkHwAll_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角スペース
			} else if (checkList[j] == "hw-space") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角スペースfunction _all
					found = checkHwSpace_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角スペースfunction  _none
					found = checkHwSpace_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//全角スペース
			} else if (checkList[j] == "fw-space") {

				// permit の場合
				if( mode == "permit" ) {

					// call 全角スペースfunction _all
					found = checkFwSpace_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 全角スペースfunction  _none
					found = checkFwSpace_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角アレファベッタ
			} else if (checkList[j] == "hw-alpha") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角アレファベッタfunction _all
					found = checkHwAlpha_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角アレファベッタfunction  _none
					found = checkHwAlpha_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角アレファベッタ 大文字
			} else if (checkList[j] == "hw-alpha-u") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角アレファベッタ 大文字function _all
					found = checkHwAlphaU_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角アレファベッタ 大文字function  _none
					found = checkHwAlphaU_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角アレファベッタ 小文字
			} else if (checkList[j] == "hw-alpha-l") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角アレファベッタ ?ｬ文字function _all
					found = checkHwAlphaL_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角アレファベッタ 小文字function  _none
					found = checkHwAlphaL_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//全角アレファベッタ
			} else if (checkList[j] == "fw-alpha") {

				// permit の場合
				if( mode == "permit" ) {

					// call 全角アレファベッタfunction _all
					found = checkFwAlpha_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 全角アレファベッタfunction  _none
					found = checkFwAlpha_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角数字
			} else if (checkList[j] == "hw-number") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角数字function _all
					found = checkHwNumber_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角数字function  _none
					found = checkHwNumber_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//全角数字
			} else if (checkList[j] == "fw-number") {

				// permit の場合
				if( mode == "permit" ) {

					// call 全角数字function _all
					found = checkFwNumber_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 全角数字function  _none
					found = checkFwNumber_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//漢字
			} else if (checkList[j] == "kanji") {

				// permit の場合
				if( mode == "permit" ) {

					// call 漢字function _all
					found = checkKanji_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 漢字function  _none
					found = checkKanji_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//ひらがな
			} else if (checkList[j] == "hiragana") {

				// permit の場合
				if( mode == "permit" ) {

					// call ひらがなfunction _all
					found = checkHiragana_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call ひらがなfunction  _none
					found = checkHiragana_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//全角カタカナ
			} else if (checkList[j] == "fw-katakana") {

				// permit の場合
				if( mode == "permit" ) {

					// call 全角カタカナfunction _all
					found = checkFwKatakana_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 全角カタカナfunction  _none
					found = checkFwKatakana_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角カタカナ
			} else if (checkList[j] == "hw-katakana") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角カタカナfunction _all
					found = checkHwKatakana_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角カタカナfunction  _none
					found = checkHwKatakana_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			//半角コード
			} else if (checkList[j] == "hw-code") {

				// permit の場合
				if( mode == "permit" ) {

					// call 半角コードfunction _all
					found = checkHwCode_All( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == true ) {
						tempFound = true;
					}

				 // perhibit の場合
				} else if( mode == "prohibit" ) {

					// call 半角コードfunction  _none
					found = checkHwCode_None( val.charAt(i) ) ;
					// if result is true,then set temporary value is true
					if( found == false ) {
						tempFound = true;
					}
				}
			}

			// if return function is true ,then jump circle
			if( tempFound == true) {
				break ;
			}

		} // end for (j = 0; j < checkList.length; j++)

		// if result is false then jump circle
		if( found == false ) {
			break ;
		}
	} // for (i = 0; i < val.length; i++)

	// set return value
	return found;
}

//******************************************************************************
// * 関数名		：文字コードによる入力チェック
// * 関数 ID		：checkCharCodeA (String val, Array checkList, String mode, int min, int max)
// * 処理内容		：文字コードによる入力チェックする
// * 書式		：blnRet =iCheck.checkCharCode(val, checkList, mode, min, max);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： min and max
// *                                  mode       ： Permit or prohibit
// *                                  min         ： 最小値
// *                                  max        ： 最大値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkCharCodeA( val, checkList, mode, min, max ) {


	var res = false ;

	// input value is empty, return value is true
	if( val == "" ) {
		return true;
	}

	if(min.indexOf("0x") < 0 ) {
		min = "0x"+min;
	}
	if(max.indexOf("0x") < 0) {
		max = "0x"+max;
	}

	//permit モード
	if(mode == "permit") {

		// check input value is among the scope
		for(var i = 0; i < val.length; i++) {

			if( val.charCodeAt(i) <= max && val.charCodeAt(i) >= min ) {
				res = true ;
			} else {
				res = false ;
			}

			if( res == false ) {
				break ;
			}
		}
	}

	//prohibit モード
	if(mode == "prohibit") {

		// check input value is among the scope
		for(var i = 0; i < val.length; i++) {

			if( val.charCodeAt(i) < max && val.charCodeAt(i) > min ) {
				res = false ;
			} else {
				res = true ;
			}

			if( res == false ) {
				break ;
			}
		}
	}
	// set retrun value
	return res;

}

//******************************************************************************
// * 関数名		：文字の長さによる入力チェック
// * 関数 ID		：checkLengthA (String val, Array checkList, int min, int max)
// * 処理内容		：文字の長さによる入力チェックする
// * 書式		：blnRet =iCheck.checkLength(val, checkList, min, max);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： min or max
// *                                  min         ： 最小値(省略可)
// *                                  max        ： 最大値(省略可)
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkLengthA( val, checkList, min, max ) {

	// input value is empty, return value is true
	if( val == "" ) {
		return true;
	}

	// judge checklist
	if(checkList.length == 0) {
		return true ;
	}

	// include min and mas in the check list
	if( checkList.length == 2) {
		if( val.length < min || val.length > max ) {
			return false;
		}
	} else {
		// include min in the checklist
		if( checkList[0] == "min") {
			if(val.length < min ) {
				return false;
			}
		}
		// include max in the checklist
		else if(checkList[0] == "max") {
			if( val.length > max) {
				return false;
			}
		}
	}

	return true;

}

//******************************************************************************
// * 関数名		：ＡＮＫで文字の長さによる入力チェック
// * 関数 ID		：checkAnkLengthA (String val, Array checkList, int min, int max)
// * 処理内容		：ＡＮＫで文字の長さによる入力チェック（全角文字を２文字と数える）
// * 書式		：blnRet =iCheck.checkAnkLength(val, checkList, min, max);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： min or max
// *                                  min         ： 最小値(省略可)
// *                                  max        ： 最大値(省略可)
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkAnkLengthA( val, checkList, min, max ) {

	// input value is empty, return value is true
	if( val == "" ) {
		return true;
	}

	// judge checklist
	if(checkList.length == 0) {
		return true ;
	}

	// check length of input value
	var cnt = val.length;
	// include min and mas in the check list
	if( checkList.length == 2) {
		if( cnt < min || cnt > max ) {
			return false;
		}
	} else {
		// include min in the checklist
		if( checkList[0] == "min") {
			if(cnt < min ) {
				return false;
			}
		}
		// include max in the checklist
		else if(checkList[0] == "max") {
			if( cnt > max) {
				return false;
			}
		}
	}

	return true;
}

//******************************************************************************
// * 関数名		：空欄でないことのチェック
// * 関数 ID		：checkNotBlankA(String val)
// * 処理内容		：空欄でないことのチェックする
// * 書式		：blnRet =iCheck.checkNotBlank(val);
// * 引数		：val	  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkNotBlankA( val ) {

	//check empty
	if( val == "") {
		return false;
	} else {
		return true;
	}

}

//******************************************************************************
// * 関数名		：メールアドレスのチェック
// * 関数 ID		：checkMailAddressA(String val)
// * 処理内容		：メールアドレスのチェックする
// * 書式		：blnRet =iCheck.checkMailAddress(val);
// * 引数		：val	  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkMailAddressA( val ) {

	// input value is empty, return value is true
	if( val == "" ) {
		return true;
	}
	//check email address
	//2011/02/02 Webサービスリニューアル対応 m.katsura UPD START
//	var atIndex = val.indexOf('@');
//	var dotIndex = val.indexOf('.', atIndex);
//	var flag = true;
//	var theSub = val.substring(0, dotIndex + 1);
//	if ((atIndex<1) || (atIndex!=val.lastIndexOf('@'))
//		|| (dotIndex<atIndex+2) || (val.length<=theSub.length)) {
//		flag = false;
//	} else {
//		flag = true;
//	}
//	return(flag);

    //正規表現での検索（半角文字チェック）
    var regexp = new RegExp("^[ -~]+$");
    var reg = regexp.test(val);
    if(reg!=true){
        //条件に当たらない場合
        return false;
    }

    var length = val.length - 1;

    //" "(半角スペース)先頭or最後でエラー
    if((val.indexOf(" ") == 0) || (val.lastIndexOf(" ") == length)){
        //先頭or最後に存在
        return false;
    }

    //'"."が無い or 先頭にある場合はエラー
    if(val.indexOf(".") < 1){
        //無しor先頭に存在
        return false;
    }

   //"."が最後にある場合エラー
    if(val.lastIndexOf(".") == length){
        return false;
    }

    var atIdx = val.indexOf("@"); 
    var atlastIdx = val.lastIndexOf("@");
    //'"@"が無い or 先頭にある場合はエラー
    if(atIdx < 1){
        //無しor先頭に存在
        return false;
    }

    //"@"が最後にある場合エラー
    if(atlastIdx == length){
        return false;
    }

   //"@"が複数の場合エラー
    if(atIdx != atlastIdx){
        return false;
    }
    
    return true;
    //2011/02/02 Webサービスリニューアル対応 m.katsura UPD END
}

//******************************************************************************
// * 関数名		：数値が一定範囲内にあるかをチェック
// * 関数 ID		：checkAnkLengthA (String val, Array checkList, int min, int max)
// * 処理内容		：数値が一定範囲内にあるかをチェックする
// * 書式		：blnRet =iCheck.checkAnkLength(val, checkList, min, max);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： min or max
// *                                  min         ： 最小値(省略可)
// *                                  max        ： 最大値(省略可)
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkNumberValueA( val, checkList, min, max ) {

	// input value is empty, return value is true
	if( val == "" ) {
		return true;
	}

	// check val type
	if( isNaN(val) ) {
		return false;
	}

	// include min and max in the check list
	if( checkList.length == 2) {
		if(  isNaN(min) || isNaN(max)) {
			return false;
		}

		if( parseFloat(val)  < parseFloat(min) || parseFloat(val) > parseFloat(max) ) {
			return false;
		}
	} else {
		// only include min in the checklist
		if( checkList[0] == "min") {
			if(  isNaN(min)) {
				return false;
			}
			if(parseFloat(val) < parseFloat(min) ) {
				return false;
			}
		}
		// only include max in the checklist
		else if(checkList[0] == "max") {
			if(  isNaN(max)) {
				return false;
			}
			if( parseFloat(val) > parseFloat(max)) {
				return false;
			}
		}
	}
	return true;

}

//******************************************************************************
// * 関数名		：日付が一定範囲内にあるかをチェック
// * 関数 ID		：checkDateValueA (String val, Array checkList, int begin, int end)
// * 処理内容		：日付が一定範囲内にあるかをチェックする
// * 書式		：blnRet =iCheck.checkDateValue(val, checkList, begin, end);
// * 引数		：val	  ： チェックの値
// *                                  checklist  ： begin or end
// *                                  begin       ： 最小値(省略可)
// *                                  end         ： 最大値(省略可)
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkDateValueA( year, month, day, checkList,  begin, end ) {

    if ( func_IsDateChkYmd ( year, month, day ) == false ) {
        return false;
    }

    var val = year + "/" + month + "/" + day

	// include min and max in the check list
	if( checkList.length == 2) {
		if( isNaN( Date.parse(begin) ) || isNaN( Date.parse(end) ) ) {
			return false ;
		}
		if( Date.parse(val)  < Date.parse(begin) || Date.parse(val) > Date.parse(end) ) {
			return false;
		}
	} else {
		// only include begin in the checklist
		if( checkList[0] == "begin") {
			if( isNaN( Date.parse(begin) )  ) {
				return false ;
			}
			if(Date.parse(val) < Date.parse(begin) ) {
				return false;
			}
		}
		// only include max in the checklist
		else if(checkList[0] == "end") {
			if( isNaN( Date.parse(end) ) ) {
				return false ;
			}
			if( Date.parse(val) > Date.parse(end)) {
				return false;
			}
		}
	}

	return true;
}

//******************************************************************************
// * 関数名		：正規表現によるチェック。
// * 関数 ID		：checkRegexpA (String val, String expression)
// * 処理内容		：正規表現によるチェック する
// * 書式		：blnRet =iCheck.checkRegexp(val,expression);
// * 引数		：val	    ： チェックの値
// *                                  expression  ： 正規表現型
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkRegexpA( val, expression ) {

	//change form of expression
	if(expression.indexOf("/") >= 0 && expression.lastIndexOf("/")+1 == expression.length) {
		expression = expression.substring(1,expression.length-1) ;
	}
	//正規表現オブジェクト作成
	var reg_obj = new RegExp(expression);

	//check val accords with expression
	return reg_obj.test(val);
}

//******************************************************************************
// * 関数名		：ユーザ作成の関数によるチェック
// * 関数 ID		：checkCustomClassA(String val, String funcName)
// * 処理内容		：ユーザ作成の関数によるチェック する
// * 書式		：ret =iCheck.checkCustomClass(val,funcName);
// * 引数		：val	    ： チェックの値
// *                                  funcName  ： ユーザが定義された関数の名前
// * 戻り値		：ret 関数の値
// *
// *
//******************************************************************************

function checkCustomClassA( val, funcName ) {

	// construct user function
	impl = funcName + "(\"" + val + "\");"
	// return evaluate result
	return eval(impl);
}

//******************************************************************************
// * 関数名		：エラーメッセージを画面に表示する
// * 関数 ID		：dispErrorMessageA(String errout, String type, String url, String target, String option)
// * 処理内容		：エラーメッセージを画面に表示する
// * 書式		：iCheck.dispErrorMessage(errout, type, url, target,  option);
// * 引数		：errout	    ： エラーメッセージ
// *			  type         ： エラー画面の種類
// *                                  url            ： 転送先のURL
// *                                  target       ： 表示対象となるフレーム
// *                                  option       ： 新規ウィンドウ作成時のオプション
// * 戻り値		：無し
// *
// *
//******************************************************************************

function dispErrorMessage( errout, type, url, target,  option ) {

	// エラーメッセジー
	message = "";
	for (i = 0; i < errout.length; i++) {
		message = message + errout[i] + "\n";
	}
	if (type == "url") {

		// _blank, _top, _self, _parent であればその指定に従う
		// 既存のフレームが指定されていたら、既存フレームで表示
		// 既存のフレームでなければ、新規ウインドウで表示

		//flag of frame name exist
		 var bolNew = true;
		 var bolFrame = true;
		 var obj= parent.frames;

		 objnew1 = parent;
		 objnew2 = self;
		 if(target != "_top" && target !="_blank" && target != "_self" && target != "_parent" ) {
		 	 bolFrame = false;
			 do {
				 obj= objnew1.frames;
				 for(var i = 0;i< obj.length ; i++) {

					if(objnew1.frames[i].name == target ) {
						bolNew = false;
						break;
					}
			             }

		         		objnew1 = objnew1.parent;
		          		objnew2 = objnew2.parent;

			} while (objnew1 != objnew2)
		}

		// judge open window type
		if(target =="_blank" || (bolFrame == false && bolNew == true)) {
			 if(option.length > 0 ) {
			 	window.open(url,target,option)
			 } else {
			 	window.open(url,target);
			 }
		} else {
			window.open(url,target)
		}


	} else if (type == "none") {
		// 何もしない
	} else {
		// default
		alert(message);
	}
}

//******************************************************************************
// * 関数名		：指定されたキーがリストに含まれているかを検索
// * 関数 ID		：existKey (Array list, String key)
// * 処理内容		：指定されたキーがリストに含まれているかを検索する
// * 書式		：blnRet =iCheck.existKey (list,key)
// * 引数		：list	    ： 項目の識別子(Array)
// *			  key          ： 検査関数名をパッケージ名から指定
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function existKey( list, key ) {

	//check key accords with among list
	for (i = 0; i < list.length; i++) {
		if (key == list[i]) {
			return true;
		}
	}
	return false;
}

//******************************************************************************
// * 関数名		：名前のformと名前のelementを存在する
// * 関数 ID		：existElement (String formname, String element)
// * 処理内容		：名前のformと名前のelementを存在する
// * 書式		：blnRet =iCheck.existElementA (formname,element)
// * 引数		：formname  ： 名前のform
// *			  element    ： 名前のelement
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function existElementA( formname, element ) {

	// test form exist
	if(typeof document.forms != "object") {
		return false;
	}
	// list all forms
	for( var i = 0 ; i < document.forms.length ; i++ ) {

		// check form name
		if(document.forms[i].name == formname ) {
			// list all elemets
			for( var j = 0; j < document.forms[i].elements.length ; j++) {
				// test name of element
				if(document.forms[i].elements[j].name == element) {

					return true ;
				}
			}
		} // end if

	}//end for

	return false ;
}

//******************************************************************************
// * 関数名		：全角文字のチェック
// * 関数 ID		：checkFwAll_All (String val)
// * 処理内容		：permit モード、全角文字のチェックする
// * 書式		：blnRet =checkFwAll_All (val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwAll_All( val ) {

	 // set return  value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//全角文字 マッチする正規表現オブジェクト作成
		var reg_str = "[\u3000, ";                                        // CharTypeFwSpace
		reg_str += "\uff21-\uff3a, \uff41-\uff5a, " ;                     // CharTypeFwAlpha
		reg_str += "\uff10-\uff19, "  ;                                   // CharTypeFwNumber
		reg_str += "\u2e80-\u2eff, \u2f00-\u2fdf, " ;                     // CharTypeKanji
		reg_str += "\u3100-\u312f,\u31a0-\u31bf,";
		reg_str += "\u3400-\u4dbf,\u4e00-\u9faf, ";
		reg_str += "\uf900-\ufaff ,";
		reg_str += "\u3040-\u309f, " ;                                    // CharHiragana
		reg_str += "\u30a0-\u30ff, " ;                                    // CharTypeFwKatakana
		reg_str += "\r\n]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角文字のチェック
// * 関数 ID		：checkFwAll_None (String val)
// * 処理内容		：prohibit モード、全角文字のチェックする
// * 書式		：blnRet =checkFwAll_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwAll_None( val ) {

	// set return  value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非全角文字 マッチする正規表現オブジェクト作成
		var reg_str = "[^\u3000, ";                                        // CharTypeFwSpace
		reg_str += "\uff21-\uff3a, \uff41-\uffff5a, " ;             // CharTypeFwAlpha
		reg_str += "\uff10-\uff19, "  ;                                 // CharTypeFwNumber
		reg_str += "\u2e80-\u2eff, \u2f00-\u2fdf, " ;             // CharTypeKanji
		reg_str += "\u3100-\u312f,\u31a0-\u31bf,";
		reg_str += "\u3400-\u4dbf,\u4e00-\u9faf, ";
		reg_str += "\uf900-\ufaff ,";
		reg_str += "\u3040-\u309f, " ;                                 // CharHiragana
		reg_str += "\u30a0-\u30ff " ;                                  // CharTypeFwKatakana
		reg_str += "]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角文字のチェック
// * 関数 ID		：checkHwAll_All (String val)
// * 処理内容		：permit モード、半角文字のチェックする
// * 書式		：blnRet =checkHwAll_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAll_All( val ) {

	// set return  value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角文字 マッチする正規表現オブジェクト作成
		var reg_str = "[\u0020-\u009f, \uff61-\uff9f]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角文字のチェック
// * 関数 ID		：checkHwAll_None (String val)
// * 処理内容		：prohibit モード、半角文字のチェックする
// * 書式		：blnRet =checkHwAll_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAll_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非半角文字 マッチする正規表現オブジェクト作成
		var reg_str = "[^\u0020-\u009f, \uff61-\uff9f]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角スペースのチェック
// * 関数 ID		：checkHwSpace_All(String val)
// * 処理内容		：permit モード、 半角スペースのチェック
// * 書式		：blnRet =checkHwSpace_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwSpace_All( val ) {

	 // set return  value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角スペース マッチする正規表現オブジェクト作成
		var reg_str = "[\u0020]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角スペースのチェック
// * 関数 ID		：checkHwSpace_None(String val)
// * 処理内容		：prohibit モード、 半角スペースのチェック
// * 書式		：blnRet =checkHwSpace_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwSpace_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非半角スペース マッチする正規表現オブジェクト作成
		var reg_str = "[^\u0020]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角スペースのチェック
// * 関数 ID		：checkFwSpace_All(String val)
// * 処理内容		：permit モード、 全角スペースのチェック
// * 書式		：blnRet =checkFwSpace_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwSpace_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//全角スペース マッチする正規表現オブジェクト作成
		var reg_str = "[\u3000]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角スペースのチェック
// * 関数 ID		：checkFwSpace_None(String val)
// * 処理内容		：prohibit モード、 全角スペースのチェック
// * 書式		：blnRet =checkFwSpace_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwSpace_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非全角スペース マッチする正規表現オブジェクト作成
		var reg_str = "[^\u3000]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角アルファベットのチェック
// * 関数 ID		：checkHwAlpha_All(String val)
// * 処理内容		：permit モード、 半角アルファベットのチェック
// * 書式		：blnRet =checkHwAlpha_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlpha_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角アルファベット マッチする正規表現オブジェクト作成
		var reg_str = "[\u0041-\u005A,\u0061-\u007A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;

}

//******************************************************************************
// * 関数名		：半角アルファベットのチェック
// * 関数 ID		：checkHwAlpha_None(String val)
// * 処理内容		：prohibit モード、 半角アルファベットのチェック
// * 書式		：blnRet =checkHwAlpha_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlpha_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非半角アルファベット マッチする正規表現オブジェクト作成
		var reg_str = "[^\u0041-\u005A,\u0061-\u007A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角アルファベット大文字のチェック
// * 関数 ID		：checkHwAlphaU_All(String val)
// * 処理内容		：permit モード、 半角アルファベット大文字のチェック
// * 書式		：blnRet =checkHwAlphaU_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlphaU_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角アルファベット大文字 マッチする正規表現オブジェクト作成
		var reg_str = "[\u0041-\u005A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角アルファベット大文字のチェック
// * 関数 ID		：checkHwAlphaU_None(String val)
// * 処理内容		：prohibit モード、 半角アルファベット大文字のチェック
// * 書式		：blnRet =checkHwAlphaU_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlphaU_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非半角アルファベット大文字 マッチする正規表現オブジェクト作成
		var reg_str = "[^(\u0041-\u005A)]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角アルファベット小文字のチェック
// * 関数 ID		：checkHwAlphaL_All(String val)
// * 処理内容		：permit モード、 半角アルファベット小文字のチェック
// * 書式		：blnRet =checkHwAlphaL_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlphaL_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角アルファベット小文字 マッチする正規表現オブジェクト作成
		var reg_str = "[\u0061-\u007A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角アルファベット小文字のチェック
// * 関数 ID		：checkHwAlphaL_None(String val)
// * 処理内容		：prohibit モード、 半角アルファベット小文字のチェック
// * 書式		：blnRet =checkHwAlphaL_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwAlphaL_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非半角アルファベット小文字 マッチする正規表現オブジェクト作成
		var reg_str = "[^(\u0061-\u007A)]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角アルファベットのチェック
// * 関数 ID		：checkFwAlpha_All(String val)
// * 処理内容		：permit モード、 全角アルファベットのチェック
// * 書式		：blnRet =checkFwAlpha_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwAlpha_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//全角アルファベット マッチする正規表現オブジェクト作成
		var reg_str = "[\uff21-\uff3A,\uff41-\uff5A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角アルファベットのチェック
// * 関数 ID		：checkFwAlpha_None(String val)
// * 処理内容		：prohibit モード、 全角アルファベットのチェック
// * 書式		：blnRet =checkFwAlpha_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwAlpha_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非全角アルファベット マッチする正規表現オブジェクト作成
		var reg_str = "[^\uff21-\uff3A,\uff41-\uff5A]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角数字のチェック
// * 関数 ID		：checkHwNumber_All(String val)
// * 処理内容		：permitモード、 半角数字のチェック
// * 書式		：blnRet =checkHwNumber_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwNumber_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//半角数字 マッチする正規表現オブジェクト作成
		var reg_str = "[\u0030-\u0039]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：半角数字のチェック
// * 関数 ID		：checkHwNumber_None(String val)
// * 処理内容		：prohibitモード、 半角数字のチェック
// * 書式		：blnRet =checkHwNumber_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwNumber_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 非半角数字 マッチする正規表現オブジェクト作成
		var reg_str = "[^\u0030-\u0039]";                       // 非半角数字アルファベット

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：全角数字のチェック
// * 関数 ID		：checkFwNumber_All(String val)
// * 処理内容		：permitモード、 全角数字のチェック
// * 書式		：blnRet =checkHwNumber_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwNumber_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 全角数字 マッチする正規表現オブジェクト作成
		var reg_str = "[\uff10-\uff19]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}


	return res;
}

//******************************************************************************
// * 関数名		：全角数字のチェック
// * 関数 ID		：checkFwNumber_None(String val)
// * 処理内容		：prohibitモード、 全角数字のチェック
// * 書式		：blnRet =checkHwNumber_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwNumber_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 非全角数字 マッチする正規表現オブジェクト作成
		var reg_str = "[^\uff10-\uff19]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：漢字のチェック
// * 関数 ID		：checkKanji_All(String val)
// * 処理内容		：permitモード、 漢字のチェック
// * 書式		：blnRet =checkKanji_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkKanji_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//漢字マッチする正規表現オブジェクト作成
		var reg_str = "[\u2e80-\u2eff, \u2f00-\u2fdf, \u3100-\u312f,";
		reg_str += "\u31a0-\u31bf, \u3400-\u4dbf,\u4e00-\u9faf, \uf900-\ufaff]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		：漢字のチェック
// * 関数 ID		：checkKanji_None(String val)
// * 処理内容		：prohibitモード、 漢字のチェック
// * 書式		：blnRet =checkKanji_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkKanji_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		//非漢字マッチする正規表現オブジェクト作成
		var reg_str = "[^\u2e80-\u2eff, \u2f00-\u2fdf, \u3100-\u312f,";
		reg_str += "\u31a0-\u31bf, \u3400-\u4dbf,\u4e00-\u9faf, \uf900-\ufaff]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： ひらがなのチェック
// * 関数 ID		：checkHiragana_All(String val)
// * 処理内容		：permitモード、  ひらがなのチェック
// * 書式		：blnRet =checkHiragana_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHiragana_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// ひらがな マッチする正規表現オブジェクト作成
		var reg_str = "[\u3040-\u309f]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： ひらがなのチェック
// * 関数 ID		：checkHiragana_None(String val)
// * 処理内容		：prohibitモード、  ひらがなのチェック
// * 書式		：blnRet =checkHiragana_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHiragana_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 非ひらがな マッチする正規表現オブジェクト作成
		var reg_str = "[^\u3040-\u309f]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： 全角カタカナのチェック
// * 関数 ID		：checkFwKatakana_All(String val)
// * 処理内容		：permitモード、  全角カタカナのチェック
// * 書式		：blnRet =checkFwKatakana_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwKatakana_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 全角カタカナ マッチする正規表現オブジェクト作成
		var reg_str = "[\u30a0-\u30ff,";
			reg_str += "\uff10-\uff19,"
			reg_str +=　"\uff08,"
			reg_str +=　"\uff09,"
			reg_str +=　"\u30fc,"
			reg_str +=　"\u30fb,"
			reg_str +=　"\u3001,"
			reg_str +=　"\u30fe,"
			reg_str += "\u3000]"  ; 
		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： 全角カタカナのチェック
// * 関数 ID		：checkFwKatakana_None(String val)
// * 処理内容		：prohibitモード、  全角カタカナのチェック
// * 書式		：blnRet =checkFwKatakana_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkFwKatakana_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 非全角カタカナ マッチする正規表現オブジェクト作成
		var reg_str = "[^\u30a0-\u30ff]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： 半角カタカナのチェック
// * 関数 ID		：checkHwKatakana_All(String val)
// * 処理内容		：permitモード、  半角カタカナのチェック
// * 書式		：blnRet =checkHwKatakana_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwKatakana_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 半角カタカナ マッチする正規表現オブジェクト作成
		var reg_str = "[\uFF61-\uFF9F]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;

}

//******************************************************************************
// * 関数名		： 半角カタカナのチェック
// * 関数 ID		：checkHwKatakana_None(String val)
// * 処理内容		：permitモード、  半角カタカナのチェック
// * 書式		：blnRet =checkHwKatakana_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwKatakana_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		 // 非半角カタカナ マッチする正規表現オブジェクト作成
		var reg_str = "[^\uff61-\uff9f]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： 半角コードのチェック
// * 関数 ID		：checkHwCode_All(String val)
// * 処理内容		：permitモード、  半角コードのチェック
// * 書式		：blnRet =checkHwCode_All(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwCode_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		// 半角コード マッチする正規表現オブジェクト作成
		var reg_str = "[\u0021-\u007e]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;

}

//******************************************************************************
// * 関数名		： 半角コードのチェック
// * 関数 ID		：checkHwCode_None(String val)
// * 処理内容		：permitモード、  半角コードのチェック
// * 書式		：blnRet =checkHwCode_None(val)
// * 引数		：val  ： チェックの値
// * 戻り値		：blnRet
// *                                  true	：正常
// *			 false	：異常
// *
//******************************************************************************

function checkHwCode_None( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		 // 非半角コード マッチする正規表現オブジェクト作成
		var reg_str = "[^\u0021-\u007e]";

		// Create regular expression object
		var reg_obj = new RegExp(reg_str);

		// check input value
		for(var i = 0; i < val.length; i++ ) {

			//check every input character with regular expression
			res = reg_obj.test( val.charAt(i) );

			// if include unregular character then skip over this circle
			if( res == false ) {
				break ;
			}
		}
	}

	return res;
}

//******************************************************************************
// * 関数名		： test function write by ユーザー
//******************************************************************************

function checkNotBlankByUser( val ) {

	if(val != "") {
		return true ;
	 } else {
	 	return false;
	}
}

//====================================================================
//機能：		日付が妥当な数値かチェックする
//引数：
//		year	(I)
//		month	(I)
//		day	(I)
//戻り値：	0	エラー  ゼロ以外 ４桁の西暦年
//====================================================================
function func_IsDateChkYmd(year, month, day){

	// input value is empty, return value is true
	if ( ( year == "" ) && ( month == "" ) && ( day == "" ) ) {
		return true;
	} else if (( year == "" ) || ( month == "" ) || ( day == "" )) {
		return false;
	}
	

	//judge format of value
	if ( isNaN( year ) || isNaN( month ) || isNaN( day ) ) {
		return false;
	}

	if( year < 0 )
		return false;
	else if( year >= 0 && year < 70 )
		year = 2000 + year;
	else if( year >= 70 && year < 100 )
		year = 1900 + year;

	if( month < 1 || month > 12 )
		return false;
	if( day < 1 || day > func_IsDateGetMonNum(year, month) )
		return false;

	return true;
}

//====================================================================
//機能：		月の日数を取得する
//引数：
//		year	(I)
//		month	(I)
//戻り値：	0	エラー  ゼロ以外 指定月の日数
//====================================================================
function func_IsDateGetMonNum(year, month){
	if( month == 1 || month == 3 || month == 5 || month == 7
	 || month == 8 || month == 10 || month == 12 )
		return 31;
	else if( month == 2 ){
		if((year%4 == 0 && year%100 != 0) || year%400 == 0)
			return 29;
		else
			return 28;
	}
	else if( month == 4 || month == 6 || month == 9 || month == 11 )
		return 30;
	else
		return 0;
}

//====================================================================
//機能：		       入力されたストリングが半角英数字であるかをチェックする。※"_"は許可する文字とする。
//引数：     val  ：チェックする必要があるストリング。
//戻り値：	true : 入力されたストリングが半角英数字、または"_"である。; false : 入力されたストリングが半角英数字ではない。
//====================================================================
function checkHwAlphaNumber_All( val ) {

	// set return value
	var res = false;

	// if input value is "" ,then return true.
	if(val == "") {
		res = true;
	} else {
		if ( !/^[a-zA-Z0-9_]+$/.test(val) ) { 
			res = false;
		}else{
			res = true;
		}
	}
	return res;
}

//====================================================================
//機能：		       入力されたストリングが電話番号であるかをチェックする。
//引数：     val  ：チェックする必要があるストリング。
//戻り値：	true : 入力されたストリングが電話番号である。; false : 入力されたストリングが電話番号ではない。
//====================================================================
function checkTelNumber( val ) {
	if(val == ""){
		return true;
	}
    var res = false;
    var reg_str = "(([0-9]{1,})([-]([0-9]{1,})([-]([0-9]{1,}))?)?)?";
    var reg_obj = new RegExp(reg_str);
    var array = new Array();
    array = reg_obj.exec(val);
    if(array != null && val == array[0]){
        return true;
    }else{
        return false;
    }
}

//====================================================================
//機能：		       入力されたストリングが区切りデータであるかをチェックする。
//引数：     value：チェックする必要があるストリング。
//戻り値：	true : 入力されたストリングが区切りデータである。; false : 入力されたストリングが区切りデータではない。
//====================================================================
function checkCountNumber(value){
	if(value == ""){
		return true;
	}
    var res = false;
    var reg_str = "(([0-9]{1,3})([,]([0-9]{3}))*)?";
    var reg_obj = new RegExp(reg_str);
    var array = new Array();
    array = reg_obj.exec(value);
    if(array != null && value == array[0]){
        return true;
    }else{
        return false;
    }
}

//====================================================================
//機能：		         入力されたストリングが実数であるかをチェックする。
//引数：     value  : チェックする必要があるストリング。
//戻り値：	true   : 入力されたストリングが実数である。; false :入力されたストリングが実数ではない。
//====================================================================
function checkRealNumber(value){
    if(value == ""){
        return true;
    }
    var res = false;
    var reg_str = "([+-]?([0-9]{1,})([.]([0-9]{1,}))?)?";
    var reg_obj = new RegExp(reg_str);
    var array = new Array();
    array = reg_obj.exec(value);
    if(array != null && value == array[0]){
        return true;
    }else{
        return false;
    }
}

//====================================================================
//機能：		日付ストリングのコネクタを取得する。当該関数は日付フォーマットをチェックする時使う。
//引数：     value  :日付ストリングを入力する。
//戻り値：	日付ストリング中のコネクタ。
//====================================================================
function getConnectivity(value){
    var length = value.length;
    var count1 = 0;
    var count2 = 0;
    for(var i = 0;i < length;i++){
        cur_char = value.charAt(i);
        if(cur_char == '-'){
            count1++;
        }
        if(cur_char == '/'){
            count2++;
        }
    }
    if(count1 == 2){
        return "-";
    }
    if(count2 == 2){
        return "/";
    }
    return null;
}


//====================================================================
//機能：		入力されたストリングが日付フォーマットであるかをチェックする。
//引数：     value  :チェックする必要あるストリング。
//戻り値：	true   :入力されたストリングが日付フォーマットである。
//          false :入力されたストリングが日付フォーマットではない。
//====================================================================
function checkDateValue(value,formatDate){
	if(value == null || value == ""){
		return true;
	}
    var valueConnectivity = getConnectivity(value);
    var formatConnectivity = getConnectivity(formatDate);
    if(valueConnectivity == null || formatConnectivity == null){
        return false;
    }
    if(valueConnectivity != formatConnectivity){
        return false;
    }
    
    var year;
    var month;
    var day;
    formatDate = formatDate.toLowerCase();
    if(value.length != formatDate.length){
        return false;
    }
    var start = 0;
    var end = 0;
    var split = 50;
    start = formatDate.indexOf("y");
    end = formatDate.lastIndexOf("y");
    if (start < 0 && end < 0) {
        year = "1970";
    }else{
        year = value.substring(start, end + 1);
        if(year > 0 && year <=split){
            year = "20" + year;
        }else if(year > split && year <=99){
            year = "19" + year;
        }
    }
    start = formatDate.indexOf("m");
    end = formatDate.lastIndexOf("m");
    if (start < 0 && end < 0) {
        month = "0";
    } else {
         month = value.substring(start, end + 1);
    }
    start = formatDate.indexOf("d");
    end = formatDate.lastIndexOf("d");
    if (start < 0 && end < 0) {
        day = "1";
    } else {
        day = value.substring(start, end + 1);
    }
    var result = checkDateValueA( year, month, day, ["begin"],  new Date(1800,01,01), null)
    return result;
}


//====================================================================
//機能：		入力されストリングに禁止入力文字が含まれているかをチェックする。
//引数：     value  :チェックする必要あるストリング。
//戻り値：	true   :禁止入力文字が含まれていない。；false :禁止入力文字が含まれている。
//			注：javascriptのチェック主関数の各チェック関数の使用上においての一致性を保持する為、
//          関数の戻りの意味と文字自身の意味を逆にしたので、使用中注意すること。
//====================================================================
function checkForbidden( val ) {
    var res = false;
	if(val == "") {
        return true;
	}else{
        var reg_str = "[\uff66-\uff9f" +                                                                   //hw-kana
        			  "\u2100-\u214f\u3200-\u33ff\u301d\u301f" +                                        //および省略文字
        			  "\u2200-\u22ff]" ;                                                                    //数学記号
		var reg_obj = new RegExp(reg_str);
		for(var i = 0; i < val.length; i++ ) {
			var cur_char = val.charAt(i);
			res = reg_obj.test(cur_char);
			if( res == true ) {
				break ;
			}
		}
        return !res;
    }
}

//====================================================================
//機能：		入力されたストリングが指定された正則表現に合っているかをチェックする。
//引数：     value  :チェックする必要あるストリング。
//			regStr :指定された正則表現。
//戻り値：	true   :指定された正則表現に合っている。；false : 指定された正則表現に合っていない。
//====================================================================
function checkRegex(value,regStr){
	if(value == ""){
		return true;
	}
	var res = false;
	var reg_obj = new RegExp(regStr);
	var array = new Array();
	array = reg_obj.exec(value);
	if(array != null && value == array[0]){
		return true;
	}else{
		return false;
	}
}

//====================================================================
//機能：		関数パラメータストリングをスキャンし、パラメータアレイを返す。
//引数：     parStr  :関数パラメータストリング。
//戻り値：パラメータアレイ。
//====================================================================
function scanParameter(parStr){
    var list = new Array();
    var curChar;
    var words;
    var curPoint = 0;
    var i = 0;
    var j = 0;
    while(i < parStr.length-1){
        curChar = parStr.charAt(i);
        if(curChar == ','){
            words = parStr.substring(curPoint,i);
            list[j] = words;
            j++;
            i++;
            curPoint = i;
        } 
        else if(curChar == '$'){
            i++;
        }else{
        }
        i++;
    }
    list[j] = parStr.substring(curPoint,i);
    return list;
}

//==============================================================================
//機能：		関数名全称によって、関数名部分を取得する。
//引数：     realFunName  :    関数名全称
//戻り値：	関数名
//==============================================================================
function getFunName(realFunName){
    var curChar;
    var i;
    var words;
    for(i = 0;i < realFunName.length;i++){
        curChar = realFunName.charAt(i);
        if(curChar == '('){
            words = realFunName.substring(0,i);
            return realFunName.substring(0,i);
        }
    }
}

//==============================================================================
//機能：	関数全称によって関数パラメータストリングを取得する。関数パラメータストリングは、関数全称において関数名と左括弧
//　　　　　　を除いた残り部分である。例：関数全称：getlastname(“neusoft”);
//　　　　　　関数名：getlastname；関数パラメータストリング：”neusoft”)である。
//引数：     realFunName  :    関数全称
//戻り値：	関数パラメータストリング
//==============================================================================
function getParameters(realFunName){
    var curChar;
    var i;
    for(i = 0;i < realFunName.length;i++){
        curChar = realFunName.charAt(i);
        if(curChar == '('){
            return realFunName.substr(i+1);
        }
    }
}


//==============================================================================
//機能：		キー値に対応しているメッセージを取得する。
//引数：     message      :    メッセージのキー値
//           args        :    メッセージにて切り替えるパラメータアレイ
//戻り値：   string       :    メッセージ
//==============================================================================
function getMessage(message,args){
    for(var i = 0;i < args.length;i++){
        message = message.replace("{" + i + "}",args[i]);
    }
    return htmlEncode(message);
}

//==============================================================================
//機能：		項目名称をjavaBeanで規範した名称に変換する。
//引数：     itemName     :    項目名称
//戻り値：   string       :    javaBean規範に合っている項目名称
//==============================================================================
function getBeanFormatItemName(itemName){
    if(itemName == null || itemName == ""){
        return itemName;
    }else{
        var headChar = "";
        var bodyChars = "";
        var chars = "";
        headChar = itemName.substr(0,1);
        bodyChars = itemName.substr(1);
        headChar = headChar.toLowerCase();
        chars = headChar.concat(bodyChars);
        return chars;
    }
}

//==============================================================================
//機能：		項目名によって項目がjsチェックを行なう必要がある項目であるかを判断する。
//引数：     itemName     :    チェックする必要がある項目名
//           realName     :    画面上の項目名
//戻り値：   boolean      :    true :チェックする必要がる。；false :チェックする必要がない。
//==============================================================================
function isJsCheckElement(itemName,realName){
    var curchar = "";
    var point = 0;
    var len = realName.length;
    for(var j = 0;j < len;j++){
        curchar = realName.charAt(j);
        if(curchar != '['){
            point = j;
        }else{
            break;
        }
    }
    var name = realName.substr(0,point+1);
    if(name == itemName){
        return true;
    }else{
        return false;
    }
}
    
//==============================================================================
//機能：		指定された名称によって、画面にてjsチェックを行なう必要がある項目アレイを取得する。
//引数：     name         :   チェックする必要がある項目名称
//           form         :    画面フォームオブジェクト
//戻り値：   array        :    画面でチェックする必要がある項目アレイ
//==============================================================================
function getJsCheckElementByName(name,form){
    
    var itemName;
    if(name == null){
        return null;
    }
    var len = 0;
    var count = 0;
    for(var i = 0;i < form.elements.length;i++){
        itemName = form.elements[i].name;
        if(isJsCheckElement(name,itemName)){
            len++;
        }
    }
    var nodeList = new Array(len);
    for(i = 0;i < form.elements.length;i++){
        itemName = form.elements[i].name;
        if(isJsCheckElement(name,itemName)){
            nodeList[count++] = form.elements[i];
        }
    }
    return nodeList;
}
    
    
//==============================================================================
//機能：		文字列の特殊文字を切り替える。
//引数：     value         :   切り替える必要がある文字列
//戻り値：   切り替えした文字列
//==============================================================================   
function replaceString(value){
    value = value.replace("$$","&dollar;");
    value = value.replace("$","");
    value = value.replace("&dollar;","$");
    return value;
}

//==============================================================================
//機能：		入力値のサブスクリプトを取得する。
//引数：     value :  入力値
//戻り値：  入力値のサブスクリプト
//==============================================================================  
function getValueIndex(value) {
    var begin = 0;
    var end = 0;
    for(var i = 0;i < value.length;i++){
        var cur_char = value.charAt(i);
        if(cur_char == '['){
            begin = i;
        }
        if(cur_char == ']'){
            end = i;
        }
    }
    if((end-begin) < 2){
        return "1";
    }
    var tmp = value.substring(begin+1,end);
    return ++tmp;
}
    
    
	function htmlEncode( value ) {
    if(value == null){
        return value;
    }
    if (typeof(value) != "string" ) return value;
    
    var msg = "";
    var cur_char;
    for(var i = 0;i < value.length;i++){
        cur_char = value.charAt(i);
        if(cur_char == '&'){
            msg = msg + "&amp;";
        }else if(cur_char == '\"'){
            msg = msg + "&quot;";
        }else if(cur_char == '<'){
            msg = msg + "&lt;";
        }else if(cur_char == '>'){
            msg = msg + "&gt;";
        }else if(cur_char == "\'"){
            msg = msg + "&#39;";
        }else{
            msg = msg + cur_char;
        }
    }
	return msg ;
	}