Squiggly/main/SpellingEngine/src/com/adobe/linguistics/spelling/core/utils/SquigglyDictionaryLoader.as - flex-utilities - Git at Google

 ////////////////////////////////////////////////////////////////////////////////
 //
 //  Licensed to the Apache Software Foundation (ASF) under one or more
 //  contributor license agreements.  See the NOTICE file distributed with
 //  this work for additional information regarding copyright ownership.
 //  The ASF licenses this file to You under the Apache License, Version 2.0
 //  (the "License"); you may not use this file except in compliance with
 //  the License.  You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 //  Unless required by applicable law or agreed to in writing, software
 //  distributed under the License is distributed on an "AS IS" BASIS,
 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////////


 package com.adobe.linguistics.spelling.core.utils
 {
 	import com.adobe.linguistics.spelling.core.LinguisticRule;
 	import com.adobe.linguistics.spelling.core.SquigglyDictionary;
 	import com.adobe.linguistics.spelling.core.env.InternalConstants;
 	import com.adobe.linguistics.spelling.core.error.*;
 	import com.adobe.linguistics.spelling.core.logging.*;

 	import flash.errors.IllegalOperationError;
 	import flash.events.Event;
 	import flash.events.EventDispatcher;
 	import flash.events.IOErrorEvent;
 	import flash.events.SecurityErrorEvent;
 	import flash.net.URLRequest;
 	import flash.utils.*;

 	public class SquigglyDictionaryLoader extends EventDispatcher
 	{
 		private var _dict:SquigglyDictionary;
 		private var _dictionaryPath:String;
 		private var _attrMgr:LinguisticRule;


 		private var snp:SimpleNumberParser = new SimpleNumberParser();

 		//setup logger for sending message.
 		private var className:String = getQualifiedClassName(this).split("::").join(".");
 		private var logger:ILogger = Log.getLogger( className );
 		//vars shifted up
         private var wordList:Array;
 		private var dp:String;//description;
 		private var ts:String;
 		private var ap:String;
 		private var flags:String;

 		private var dpPattern1:RegExp; 	//patterns to split rule line into fileds according to new morphological field separator
 		private var dpPattern2:RegExp;	//patterns to split rule line into fileds according to old morphological field separator
 		private var tsPattern1:RegExp;	//extracts the affix string
 		private var strArr:Array;
 		private var lineContent:String;
 		private var totalPart:int;
 		private var delay:int;
 		//vars shifted up

 		//variables added to accomodate property
 		private var _enableDictionarySplit:Boolean;
 		private var _wordsPerDictionarySplit:int;

 		public function SquigglyDictionaryLoader()
 		{
 			_dict = null;
 			_dictionaryPath = null;
 			_attrMgr = null;
 			dpPattern1= /^(.+)[ \t]+.{2}:(.+)$/ ; 	//patterns to split rule line into fileds according to new morphological field separator
 			dpPattern2= /^(.+)[\t]{1}(.+)$/ ; 		//patterns to split rule line into fileds according to old morphological field separator
 			tsPattern1= /^(.*[^\\])\/(.+)$/ ;
 			delay=InternalConstants.DICT_LOAD_DELAY; //the timeout period between two parts 10 ms
 		}

 		public function set linguisticRule(value:LinguisticRule):void {
 			this._attrMgr = value;
 		}

 		public function get linguisticRule():LinguisticRule {
 			return this._attrMgr;
 		}

 		public function load(dictionaryURL:String,enableDictionarySplit:Boolean,wordsPerDictionarySplit:int):void {
 			if ( dictionaryURL == null ) {
 				throw new IllegalOperationError("load function did not receive two valid URLs.");
 			}
 			_dictionaryPath = dictionaryURL;
 			_enableDictionarySplit=enableDictionarySplit;
 			_wordsPerDictionarySplit=wordsPerDictionarySplit;
 			var request:URLRequest = new URLRequest( _dictionaryPath );
 			var dloader:DictionaryLoader = new DictionaryLoader(request);
 			dloader.addEventListener(Event.COMPLETE,loadDictionaryComplete);
 			dloader.addEventListener(IOErrorEvent.IO_ERROR,handleError);
 			dloader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleError);

 		}

 		//Private method to dispatch an error event.
 		private function handleError(evt:Event):void {
 			bounceEvent(evt);
 		}
 		private function bounceEvent(evt:Event):void {
 			dispatchEvent(evt.clone());
 		}


 		public function get squigglyDictionary():SquigglyDictionary {
 			return  _dict;
 		}

 		private function loadDictionaryComplete(evt:Event):void {
 			_dict = new SquigglyDictionary(_attrMgr);

 			var bytes:ByteArray = evt.target.data;
 			//trace("load complete handler: "+getTimer()+" "+bytes.bytesAvailable);
 			var charSet:String;
 			if ( _attrMgr ) {
 				charSet = _attrMgr.encoding;
 			}else {
 				charSet = InternalConstants.DEFAULTENCODING;
 			}
 			var str:String = 	bytes.readMultiByte(bytes.length, charSet);
 			//trace("Bytes read at: "+getTimer());

 			/*
 			In DOS, a line break is a single '\n'.
 			In Unix, a line break is the sequence '\r\n'.
 			In MAC, a line break is a single '\r'.
 			Correct me if I'm wrong.
 			so step 1:
 			replace "\r\n" with "\n"
 			step 2:
 			replace "\r" with "\n";
 			finally ,we get "\n" line seperator.
 			*/
 			str=str.split("\r\n").join("\n");
 			str=str.split("\r").join("\n");
 			wordList= str.split("\n");
 			//bof of parsing the text.
 			//trace("Wordlist length: "+wordList.length);
 			if(wordList== null ) {
 				logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data]",this._dictionaryPath);
 			}
 			if(wordList.length== 1){
 				logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data]",this._dictionaryPath );
 //				logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data] Line Number:{1}, Content:{2}",this._rulePath , (lineNumber+1).toString(),lineContent );
 			}
 			//fix for 	Bug #: 	2855795 now if greater load to a max of wordList.length
 			if(wordList.length<this._wordsPerDictionarySplit){
 				this._wordsPerDictionarySplit=wordList.length;
 			}

 			/* remove byte order mark */
 			if ( wordList[0].match(new RegExp("^\xEF\xBB\xBF[.]+$") ) ) wordList[0]=wordList[0].substr(3);
 			var snp:SimpleNumberParser = new SimpleNumberParser();
 			/* get the table size */
 			var tablesize:int = snp.parse(wordList[0]);
 			if (tablesize == 0) throw new ContentError(ErrorTable.CONTENTPARSINGERROR_MSG,ErrorTable.CONTENTPARSINGERROR_ID);

 			//trace("Before parsing: "+getTimer());

 			if(this._enableDictionarySplit ){
 				setTimeout(loadWithTimeouts,1,1);//go to loadWithTimeouts
 			}
 			else
 			{
 				setTimeout(loadWithoutTimeouts,1,1);//directly go to finish. This will cause words to load from 1 to wordList.length
 			}

 		}

 		private function loadWithTimeouts(part:int):void	{
 			for( var line:int = part; line<part+(this._wordsPerDictionarySplit)-1; ++line) {
 				lineContent = wordList[line];
 				/* : is the new morphological field separator */
 				if ( (strArr = lineContent.match(dpPattern1)) != null ) {
 					dp=strArr[2];
 					ts = strArr[1];
 				/* tabulator is the old morphological field separator */
 				}else if ( (strArr = lineContent.match(dpPattern2)) != null ) {
 					ts = strArr[1];
 					dp=strArr[2];
 				}else {
 					ts = lineContent;//so ts has the word and dp has morphological desc
 					dp = null;
 				}

 				ts= StringUtils.trim(ts);
 				if( dp != null ) dp= StringUtils.trim(dp);
 				// eof: split each line into word and morphological description

 				// bof:split each line into word and affix char strings
 				/*
 				"\/" signs slash in words (not affix separator)
 				"/" at beginning of the line is word character (not affix separator)
 				*/
 				if ( (strArr = ts.match(tsPattern1))!= null ) {
 					ap = strArr[2];
 					ts = strArr[1];
 					ts = ts.split('\\/').join('/');	/* replace "\/" with "/" */
 					if(_attrMgr){
 						if(_attrMgr.aliasfTable && _attrMgr.aliasfTable.length>0)
 						{
 						flags=_attrMgr.aliasfTable[parseInt(ap,10)-1];
 						}
 						else
 						{
 						flags = decodeFlags( ap, _attrMgr.flagMode);
 						}
 					}
 /*
 // Todo, will remove this comments after we have complex-affix support and compound-word support.
             if (aliasf) {
                 int index = atoi(ap + 1);
                 al = get_aliasf(index, &flags, dict);
                 if (!al) {
                     HUNSPELL_WARNING(stderr, "error: line %d: bad flag vector alias\n", dict->getlinenum());
                     *ap = '\0';
                 }
             } else {
                 al = decode_flags(&flags, ap + 1, dict);
                 flag_qsort(flags, 0, al);
             }
 */
 				}else {
 					ap=null;
 					flags=null;
 				}
 				// eof:split each line into word and affix char strings
 				//trace(line+" WORD:"+ts);
 				_dict.addWord( ts, flags, dp );
 		}

 				if(line+(this._wordsPerDictionarySplit)>=wordList.length)//Last part reached.
 				{
 					setTimeout(loadWithoutTimeouts,delay,line);//the last part left which is less than wordsPerDictionarySplit is loaded w/o Timeouts
 				}
 				else
 				{
 				setTimeout(loadWithTimeouts,delay, line);//get delay of 10 ms
 				}
 			// } //loop ends
 			//eof of parsing the text.
 			//function ends here
 		}

 		/* Squiggly function to end Asynchronous looping
 		*
 		*
 		*/
 		private function loadWithoutTimeouts(line:int):void
 		{
 			for( ; line<wordList.length; ++line) {

 				// bof: split each line into word and morphological description
 				lineContent = wordList[line];
 				/* : is the new morphological field separator */
 				if ( (strArr = lineContent.match(dpPattern1)) != null ) {
 					dp=strArr[2];
 					ts = strArr[1];
 					/* tabulator is the old morphological field separator */
 				}else if ( (strArr = lineContent.match(dpPattern2)) != null ) {
 					ts = strArr[1];
 					dp=strArr[2];
 				}else {
 					ts = lineContent;
 					dp = null;
 				}
 				ts= StringUtils.trim(ts);
 				if( dp != null ) dp= StringUtils.trim(dp);
 				// eof: split each line into word and morphological description

 				// bof:split each line into word and affix char strings
 				/*
 				"\/" signs slash in words (not affix separator)
 				"/" at beginning of the line is word character (not affix separator)
 				*/
 				if ( (strArr = ts.match(tsPattern1))!= null ) {
 					ap = strArr[2];
 					ts = strArr[1];
 					ts = ts.split('\\/').join('/');	/* replace "\/" with "/" */
 					if(_attrMgr)
 					{
 						if(_attrMgr.aliasfTable && _attrMgr.aliasfTable.length>0)
 						{
 						flags=_attrMgr.aliasfTable[parseInt(ap,10)-1];
 						}
 						else
 						{
 						flags = decodeFlags( ap, _attrMgr.flagMode);
 						}
 					}
 					/*
 					// Todo, will remove this comments after we have complex-affix support and compound-word support.
 					if (aliasf) {
 					int index = atoi(ap + 1);
 					al = get_aliasf(index, &flags, dict);
 					if (!al) {
 					HUNSPELL_WARNING(stderr, "error: line %d: bad flag vector alias\n", dict->getlinenum());
 					*ap = '\0';
 					}
 					} else {
 					al = decode_flags(&flags, ap + 1, dict);
 					flag_qsort(flags, 0, al);
 					}
 					*/
 				}else {
 					ap=null;
 					flags=null;
 				}
 				// eof:split each line into word and affix char strings
 				//trace("WORD2:"+ts);
 				_dict.addWord( ts, flags, dp );
 			}
 			//trace("After Parsing: "+getTimer());
 			logger.info("Dictionary File[{0}] Operation[parsing] Total Lines:{1}, Unrecognized Lines:{2}", this._dictionaryPath ,wordList.length.toString(), 0  );

 			dispatchEvent(new Event(Event.COMPLETE));
 		}


 		/*
 		 * Squiggly is using utf16 by default...
 		 * for utf8 string conversion,we need extra work later.
 		 * we might also need a better toString() fuction for Flag_long and flag_num mode.
 		 */
 		private function decodeFlags(flags:String, flagMode:int):String {
 			var result:String="";
 			var i:int;
 			switch ( flagMode )  {
 				case InternalConstants.FLAG_LONG:
 				if ( (flags.length)%2 == 1 ) {
 					logger.error("Dictionary File[{0}] Operation[parsing] Error[decoding error] target flags:{1}",this._dictionaryPath , flags );
 					throw new ContentError(ErrorTable.CONTENTPARSINGERROR_MSG,ErrorTable.CONTENTPARSINGERROR_ID);
 				}
 				var len:int = flags.length/2;
 				for ( i = 0; i< len; ++i ) {
 					result +=  String.fromCharCode( ((flags.charCodeAt((i * 2))) << 8) + (flags.charCodeAt((i * 2 + 1))) );
 				}
 				break;
 				case InternalConstants.FLAG_NUM:
 				var strArr:Array = flags.split(",");
 				for ( i = 0;i< strArr.length;++i) {
 					var num:Number = snp.parse(strArr[i]);
 					if ( num >= InternalConstants.DEFAULTFLAGS ) {
 						logger.error("Dictionary File[{0}] Operation[parsing] Error[decoding error] target flags:{1}",this._dictionaryPath , flags );
 					}
 					result += String.fromCharCode(num);
 				}
 				break;
 				case InternalConstants.FLAG_UNI:
 				result = flags;
 				break;
 				default:
 				result = flags;
 				break;
 			}
 			return result;
 		}


 	}
 }
	////////////////////////////////////////////////////////////////////////////////
	//
	// Licensed to the Apache Software Foundation (ASF) under one or more
	// contributor license agreements. See the NOTICE file distributed with
	// this work for additional information regarding copyright ownership.
	// The ASF licenses this file to You under the Apache License, Version 2.0
	// (the "License"); you may not use this file except in compliance with
	// the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	////////////////////////////////////////////////////////////////////////////////


	package com.adobe.linguistics.spelling.core.utils
	{
	import com.adobe.linguistics.spelling.core.LinguisticRule;
	import com.adobe.linguistics.spelling.core.SquigglyDictionary;
	import com.adobe.linguistics.spelling.core.env.InternalConstants;
	import com.adobe.linguistics.spelling.core.error.*;
	import com.adobe.linguistics.spelling.core.logging.*;

	import flash.errors.IllegalOperationError;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLRequest;
	import flash.utils.*;

	public class SquigglyDictionaryLoader extends EventDispatcher
	{
	private var _dict:SquigglyDictionary;
	private var _dictionaryPath:String;
	private var _attrMgr:LinguisticRule;


	private var snp:SimpleNumberParser = new SimpleNumberParser();

	//setup logger for sending message.
	private var className:String = getQualifiedClassName(this).split("::").join(".");
	private var logger:ILogger = Log.getLogger( className );
	//vars shifted up
	private var wordList:Array;
	private var dp:String;//description;
	private var ts:String;
	private var ap:String;
	private var flags:String;

	private var dpPattern1:RegExp; //patterns to split rule line into fileds according to new morphological field separator
	private var dpPattern2:RegExp; //patterns to split rule line into fileds according to old morphological field separator
	private var tsPattern1:RegExp; //extracts the affix string
	private var strArr:Array;
	private var lineContent:String;
	private var totalPart:int;
	private var delay:int;
	//vars shifted up

	//variables added to accomodate property
	private var _enableDictionarySplit:Boolean;
	private var _wordsPerDictionarySplit:int;

	public function SquigglyDictionaryLoader()
	{
	_dict = null;
	_dictionaryPath = null;
	_attrMgr = null;
	dpPattern1= /^(.+)[ \t]+.{2}:(.+)$/ ; //patterns to split rule line into fileds according to new morphological field separator
	dpPattern2= /^(.+)[\t]{1}(.+)$/ ; //patterns to split rule line into fileds according to old morphological field separator
	tsPattern1= /^(.*[^\\])\/(.+)$/ ;
	delay=InternalConstants.DICT_LOAD_DELAY; //the timeout period between two parts 10 ms
	}

	public function set linguisticRule(value:LinguisticRule):void {
	this._attrMgr = value;
	}

	public function get linguisticRule():LinguisticRule {
	return this._attrMgr;
	}

	public function load(dictionaryURL:String,enableDictionarySplit:Boolean,wordsPerDictionarySplit:int):void {
	if ( dictionaryURL == null ) {
	throw new IllegalOperationError("load function did not receive two valid URLs.");
	}
	_dictionaryPath = dictionaryURL;
	_enableDictionarySplit=enableDictionarySplit;
	_wordsPerDictionarySplit=wordsPerDictionarySplit;
	var request:URLRequest = new URLRequest( _dictionaryPath );
	var dloader:DictionaryLoader = new DictionaryLoader(request);
	dloader.addEventListener(Event.COMPLETE,loadDictionaryComplete);
	dloader.addEventListener(IOErrorEvent.IO_ERROR,handleError);
	dloader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleError);

	}

	//Private method to dispatch an error event.
	private function handleError(evt:Event):void {
	bounceEvent(evt);
	}
	private function bounceEvent(evt:Event):void {
	dispatchEvent(evt.clone());
	}


	public function get squigglyDictionary():SquigglyDictionary {
	return _dict;
	}

	private function loadDictionaryComplete(evt:Event):void {
	_dict = new SquigglyDictionary(_attrMgr);

	var bytes:ByteArray = evt.target.data;
	//trace("load complete handler: "+getTimer()+" "+bytes.bytesAvailable);
	var charSet:String;
	if ( _attrMgr ) {
	charSet = _attrMgr.encoding;
	}else {
	charSet = InternalConstants.DEFAULTENCODING;
	}
	var str:String = bytes.readMultiByte(bytes.length, charSet);
	//trace("Bytes read at: "+getTimer());

	/*
	In DOS, a line break is a single '\n'.
	In Unix, a line break is the sequence '\r\n'.
	In MAC, a line break is a single '\r'.
	Correct me if I'm wrong.
	so step 1:
	replace "\r\n" with "\n"
	step 2:
	replace "\r" with "\n";
	finally ,we get "\n" line seperator.
	*/
	str=str.split("\r\n").join("\n");
	str=str.split("\r").join("\n");
	wordList= str.split("\n");
	//bof of parsing the text.
	//trace("Wordlist length: "+wordList.length);
	if(wordList== null ) {
	logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data]",this._dictionaryPath);
	}
	if(wordList.length== 1){
	logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data]",this._dictionaryPath );
	// logger.error("Dictionary File[{0}] Operation[parsing] Error[corrupt data] Line Number:{1}, Content:{2}",this._rulePath , (lineNumber+1).toString(),lineContent );
	}
	//fix for Bug #: 2855795 now if greater load to a max of wordList.length
	if(wordList.length<this._wordsPerDictionarySplit){
	this._wordsPerDictionarySplit=wordList.length;
	}

	/* remove byte order mark */
	if ( wordList[0].match(new RegExp("^\xEF\xBB\xBF[.]+$") ) ) wordList[0]=wordList[0].substr(3);
	var snp:SimpleNumberParser = new SimpleNumberParser();
	/* get the table size */
	var tablesize:int = snp.parse(wordList[0]);
	if (tablesize == 0) throw new ContentError(ErrorTable.CONTENTPARSINGERROR_MSG,ErrorTable.CONTENTPARSINGERROR_ID);

	//trace("Before parsing: "+getTimer());

	if(this._enableDictionarySplit ){
	setTimeout(loadWithTimeouts,1,1);//go to loadWithTimeouts
	}
	else
	{
	setTimeout(loadWithoutTimeouts,1,1);//directly go to finish. This will cause words to load from 1 to wordList.length
	}

	}

	private function loadWithTimeouts(part:int):void {
	for( var line:int = part; line<part+(this._wordsPerDictionarySplit)-1; ++line) {
	lineContent = wordList[line];
	/* : is the new morphological field separator */
	if ( (strArr = lineContent.match(dpPattern1)) != null ) {
	dp=strArr[2];
	ts = strArr[1];
	/* tabulator is the old morphological field separator */
	}else if ( (strArr = lineContent.match(dpPattern2)) != null ) {
	ts = strArr[1];
	dp=strArr[2];
	}else {
	ts = lineContent;//so ts has the word and dp has morphological desc
	dp = null;
	}

	ts= StringUtils.trim(ts);
	if( dp != null ) dp= StringUtils.trim(dp);
	// eof: split each line into word and morphological description

	// bof:split each line into word and affix char strings
	/*
	"\/" signs slash in words (not affix separator)
	"/" at beginning of the line is word character (not affix separator)
	*/
	if ( (strArr = ts.match(tsPattern1))!= null ) {
	ap = strArr[2];
	ts = strArr[1];
	ts = ts.split('\\/').join('/'); /* replace "\/" with "/" */
	if(_attrMgr){
	if(_attrMgr.aliasfTable && _attrMgr.aliasfTable.length>0)
	{
	flags=_attrMgr.aliasfTable[parseInt(ap,10)-1];
	}
	else
	{
	flags = decodeFlags( ap, _attrMgr.flagMode);
	}
	}
	/*
	// Todo, will remove this comments after we have complex-affix support and compound-word support.
	if (aliasf) {
	int index = atoi(ap + 1);
	al = get_aliasf(index, &flags, dict);
	if (!al) {
	HUNSPELL_WARNING(stderr, "error: line %d: bad flag vector alias\n", dict->getlinenum());
	*ap = '\0';
	}
	} else {
	al = decode_flags(&flags, ap + 1, dict);
	flag_qsort(flags, 0, al);
	}
	*/
	}else {
	ap=null;
	flags=null;
	}
	// eof:split each line into word and affix char strings
	//trace(line+" WORD:"+ts);
	_dict.addWord( ts, flags, dp );
	}

	if(line+(this._wordsPerDictionarySplit)>=wordList.length)//Last part reached.
	{
	setTimeout(loadWithoutTimeouts,delay,line);//the last part left which is less than wordsPerDictionarySplit is loaded w/o Timeouts
	}
	else
	{
	setTimeout(loadWithTimeouts,delay, line);//get delay of 10 ms
	}
	// } //loop ends
	//eof of parsing the text.
	//function ends here
	}

	/* Squiggly function to end Asynchronous looping
	*
	*
	*/
	private function loadWithoutTimeouts(line:int):void
	{
	for( ; line<wordList.length; ++line) {

	// bof: split each line into word and morphological description
	lineContent = wordList[line];
	/* : is the new morphological field separator */
	if ( (strArr = lineContent.match(dpPattern1)) != null ) {
	dp=strArr[2];
	ts = strArr[1];
	/* tabulator is the old morphological field separator */
	}else if ( (strArr = lineContent.match(dpPattern2)) != null ) {
	ts = strArr[1];
	dp=strArr[2];
	}else {
	ts = lineContent;
	dp = null;
	}
	ts= StringUtils.trim(ts);
	if( dp != null ) dp= StringUtils.trim(dp);
	// eof: split each line into word and morphological description

	// bof:split each line into word and affix char strings
	/*
	"\/" signs slash in words (not affix separator)
	"/" at beginning of the line is word character (not affix separator)
	*/
	if ( (strArr = ts.match(tsPattern1))!= null ) {
	ap = strArr[2];
	ts = strArr[1];
	ts = ts.split('\\/').join('/'); /* replace "\/" with "/" */
	if(_attrMgr)
	{
	if(_attrMgr.aliasfTable && _attrMgr.aliasfTable.length>0)
	{
	flags=_attrMgr.aliasfTable[parseInt(ap,10)-1];
	}
	else
	{
	flags = decodeFlags( ap, _attrMgr.flagMode);
	}
	}
	/*
	// Todo, will remove this comments after we have complex-affix support and compound-word support.
	if (aliasf) {
	int index = atoi(ap + 1);
	al = get_aliasf(index, &flags, dict);
	if (!al) {
	HUNSPELL_WARNING(stderr, "error: line %d: bad flag vector alias\n", dict->getlinenum());
	*ap = '\0';
	}
	} else {
	al = decode_flags(&flags, ap + 1, dict);
	flag_qsort(flags, 0, al);
	}
	*/
	}else {
	ap=null;
	flags=null;
	}
	// eof:split each line into word and affix char strings
	//trace("WORD2:"+ts);
	_dict.addWord( ts, flags, dp );
	}
	//trace("After Parsing: "+getTimer());
	logger.info("Dictionary File[{0}] Operation[parsing] Total Lines:{1}, Unrecognized Lines:{2}", this._dictionaryPath ,wordList.length.toString(), 0 );

	dispatchEvent(new Event(Event.COMPLETE));
	}



	/*
	* Squiggly is using utf16 by default...
	* for utf8 string conversion,we need extra work later.
	* we might also need a better toString() fuction for Flag_long and flag_num mode.
	*/
	private function decodeFlags(flags:String, flagMode:int):String {
	var result:String="";
	var i:int;
	switch ( flagMode ) {
	case InternalConstants.FLAG_LONG:
	if ( (flags.length)%2 == 1 ) {
	logger.error("Dictionary File[{0}] Operation[parsing] Error[decoding error] target flags:{1}",this._dictionaryPath , flags );
	throw new ContentError(ErrorTable.CONTENTPARSINGERROR_MSG,ErrorTable.CONTENTPARSINGERROR_ID);
	}
	var len:int = flags.length/2;
	for ( i = 0; i< len; ++i ) {
	result += String.fromCharCode( ((flags.charCodeAt((i * 2))) << 8) + (flags.charCodeAt((i * 2 + 1))) );
	}
	break;
	case InternalConstants.FLAG_NUM:
	var strArr:Array = flags.split(",");
	for ( i = 0;i< strArr.length;++i) {
	var num:Number = snp.parse(strArr[i]);
	if ( num >= InternalConstants.DEFAULTFLAGS ) {
	logger.error("Dictionary File[{0}] Operation[parsing] Error[decoding error] target flags:{1}",this._dictionaryPath , flags );
	}
	result += String.fromCharCode(num);
	}
	break;
	case InternalConstants.FLAG_UNI:
	result = flags;
	break;
	default:
	result = flags;
	break;
	}
	return result;
	}


	}
	}