------------------------------------------------------------------------------
Hot Soup Processor ver3.6                           HSP : Hot Soup Processor  
SDKdlKCh                         copyright 1997-2021 (c) onion software  
------------------------------------------------------------------------------

EvOCJ}jA

͂߂

	̃eLXǵAHot Soup Processor ver3.0ȍ~ɑΉvOCJ
	߂̉ю܂܂Ă܂B
	HSPvOĆAHSPg邽߂̍xȕ@łB
	荂xHSPgpƂ̂߂̎ił̂ŁA킩Ȃ
	ǂ܂ȂĂ͂܂B

	̃eLXǵAC܂́AC++ɂĂ̒mΏۂɂĂ܂B
	܂AWindowsvO~OɂĂ̒m΂[HSP̃\[X
	gƂł܂BWindowsvO~O܂킩ȂꍇłA
	ANZX݂̂ŉʂȂǁAx̃vO~O\
	łB


HSPgvOC̋K

	HSPFe탊\[X@\g邽߂̊OvO
	uHSPgvOCvƌĂт܂B
	HSPgvOĆAOt@CĂяouDLLvOvƁA
	X^eBbNɃNꂽ̂ĂяouX^eBbNCuv
	̂ǂ炩łp\ɂȂĂ܂B

	uHSPgvOCvł͓̐ɂ܂BȂA
	lIȗprōꍇAzz̔ړIƂꍇłĂ
	HSP̍(ONION software)ɖfŉ^pĂ܂܂B

	AuHSPgvOCvgpċNsguȂǂ
	ӔCHSP(ONION software)͕˂܂B

	uHSPgvOCvzzꍇ́AHSPɑΉgvOCł
	|hLgɖLāAȂׂHSP{̂̓A

	uHSPTV!v
	https://hsp.tv/

	܂́A

	uHot Soup Processor Pagev
	https://www.onionsoft.net/hsp/

	𖾋LĂ炦ƊłB

	܂AuHSPgvOCDLLv̊gq́ADLL܂HPÎǂ炩g悤
	Ă܂BgqHPÍAʏDLLƋʂ邽߂ƁAWindows̐ݒ
	gqDLL\ȂȂĂꍇɑΏ̂߂̂̂łB


̃hLg̃o[W

	HSP ver3.6

	HSP3.6ŏCꂽBMSCR\̃oɂĖL܂B
	HSPEXINFO\̓HspFunc_getobj/HspFunc_setobj̃IuWFNgID͈̓`FbNǉ܂B

	HSP ver3.5

	HSP3.6Œǉꂽp[^[擾Acode_getns/code_getndsɂĒǋL܂B

	HSP ver3.24

	HSP3.2ŒǉꂽBMSCR\̃oC܂B
	hpi3sampletH_̃wb_t@CXVĂ܂B

	HSP ver3.19

	8HSPCTX̃oeɌ݊ȂȂĂߏC܂B
	(HSPCTX\̂C܂B)
	HSP3vOC8ō쐬Ăꍇ́A萔łA9ł
	ēxrhĒ悤肢܂B

	HSP ver3.18

	VKvOC̃\[Xǉ܂B
	ϐɊւT[rXǉ܂B(HSPEXINFO\̂C܂B)

	HSP ver3.17

	tH_\ꕔύX܂B
	Tv\[XƂāAWvOC\[XR[h𓯍܂B
	ϐ^gTvƂhpi3typevWFNg𓯍܂B
	OG[(WindowsG[)ߊlȂfobOłhsp3.exe𓯍܂B
	XNvgGfB^SDK𓯍܂B

	HSP ver3.16

	}`Xbhł̃CuAhsp3dlib_mt.libAhsp3lib_mt.libǉ܂B

	HSP ver3.14

	HSPEXINFO\̂C܂B

	HSP ver3.0a

	HSPEXINFO\̓HspFunc_prm_getv֐̋C܂B
	HSP2.61݊mpval̒lQƂł悤ɂȂĂ܂B
	#regcmdɕϐ^g̃p[^[ǉ܂B

	HSP ver3.012

	zwĂȂObjectWriteĂ΂Ȃ悤ɏCB

	HSP ver3.011

	֐p[^[擾dlCB
	PVal̎ʏHSPVAR_SUPPORT_TEMPVAR(e|ϐ)ǉB
	HspFunc_dimn߂Ƃzϐp̃T|[g֐ǉB

	HSP ver3.09

	̈ꕔ⑫AC܂B

	HSP ver3.08

	HSPEXINFO\̂C܂B
	vOC̃\[XēxrhKv̂ŒӂĂB

	HSP ver3.07

	uHSPwb_ɂāvuCuɂāvǉB

	HSP ver3.06

	fBNg̍\ύX܂B

	HSP ver3.02

	HSPtZbgHSPSDKƗĔzz`ɕύX܂B

	HSP ver3.012

	HspVarProc\̂ꕔC܂B

	HSP ver3.011

	HspVarProc\̂ꕔC܂B
	HSPEXINFO\̂ꕔC܂B

	HSP ver3.010

	HspVarProc\̂ꕔC܂B
	HSPEXINFO\̂ꕔC܂B

	HSP ver3.08

	HSPCTX\̂ꕔC܂B

	HSP ver3.07

	code_getvAcode_setv̊֐ꂼcode_getvaAcode_setva
	ύX܂BlύXĂ邽߁AȑÕ\[XύX悤
	肢v܂B
	HspVarProc\̂̓eꕔύX܂B

	HSP ver3.05

	\̂̈ꕔXV܂B
	HSP3VarFunctioñTv𓯍B

	HSP ver3.04

	vOC쐬̂߂̃TvyуhLg𓯍B
	ver 2.61܂ł̃vOCƂ̌݊͂܂B
	܂AłɌĎdlύX邱Ƃ̂łB


TvvOɂ

	TvvOAуvOC쐬p̃wb_t@C
	uhpi3samplevfBNgɒuĂ܂B
	̃Tv\[Xł́A쐬Ⴊ܂܂Ă܂B


vOCJɕKvȂ

	HSPgvOCDLLgpꍇ́AWindows 32bit DLL_Ci~bN
	N܂BX^eBbNCȕꍇ́AHSP^CƃNāA
	vOC𓯍`̃^C쐬ł`ɂȂ܂B

	vOC̊J́AɐȂWindows API⃉Cugpł܂B
	DLLACu쐬邱Ƃł΁A͖₢܂B
	̃eLXgł́ADLL쐬邽߂̃c[ƂāA{I
	Microsoft Visual C++(6.0ȍ~)ΏۂɂĉĂ܂B
	Borland C++AC++ BuilderłDLL쐬\łARpC⃊N
	̂߂ɈꕔCKvꍇ܂B


Ver2.61܂ł̃vOCƂ̈Ⴂ

	HSP3ł́AȑÕo[W̓vOC̒`኱قȂĂ܂B
	HSP3ł́AODLLCӂ̈ŌĂяo@\APDLLĂяo
	sȂ̏ꍇ́AgvOCƂ͋ʂ܂B
	HSP3̃vOĆAHSP3VXeƘAgē삷pDLL
	ʏ̊ODLLĂяõ\[XɃANZX邱Ƃł܂B
	ȉɗ҂̈Ⴂ܂Ƃ߂܂B

	EHSP3vOC

		#regcmdA#cmd߂ɂo^
		߁E֐ѕϐ^̐VK쐬\
		ϐ̌^ǗɃANZX\
		obt@̎mہACxg̃Lv`[\

	EDLLĂяo

		#uselibA#func߂ɂo^
		߂̐VK쐬\
		ϐ̌^ǗɃANZX\
		obt@̎mہACxg̃Lv`[\

	vOC̃\[XR[hꕔC邱ƂŁAHSP3vOCƂē
	邱Ƃł܂̂ŁA񂷂ׂĂ̋@\oƂ̂ł
	HSP3vOCƂĐVKɃ[XĒƊłB


Ver2.61vOCƂ̌݊

	ŁAHSP2.5ȍ~̂؂ẴvOCKɑΉĂ܂A
	HSP3.0̓dlύXɂ鐧̂ŁAӂKvłB

	EBMSCR\̂́Aflagcolor܂ł̃tB[ĥݎQƂł܂B
	EPVal\̂́Aver2.5PVAL2\̂ƌ݊܂B
	EPVal\̂flagtB[h(^^Cvl)lentB[h(z)
	@DLLŏ邱Ƃ͂ł܂B
	EPVal\̂當^̔zϐɃANZX邱Ƃ͂ł܂B
	EHSPEXINFO\̂stmptB[hrefstrƓ̃obt@gp܂B

	ȊO̓_ɂẮAHSP ver2.61Ɠ̏񂪎󂯓n܂B
	HSP2.61݊̃vOCł́Aȉ̂悤Ȑ܂̂Œ
	ĂB
	܂AvOČ݊@\ׂ͂ĂHSP2.xvOC̓ۏႷ
	̂ł͂܂B

	EvOCϐɒlꍇAobt@̎g͍sȂ܂B
	@(obt@I[o[t[Ȃ悤ɒӂĂ)


HSP3VXeTv

	HSP3VXéAR[h̎s̃ubNɕꂽ\Ă܂B
	HSP3TypeFunctiońAL[[hJeS(^Cv)Ƃ̎sƎQƂA
	HSP3VarFunctiońAϐɊi[^Ƃ̃f[^ǗsȂĂ܂B
	ꂼ̃ubŃACӂɕ邱ƂłAvOC(ODLL)ɐU蕪
	Ƃ\łB

	HSP3RAVXe

	    HSP3R[h}l[W[

		HSP3TypeFunction ()
		HSP3TypeFunction (`施)
		HSP3TypeFunction (}`fBA)
		HSP3TypeFunction (g)
		HSP3TypeFunction (w֐)

	    HSP3Xg[W}l[W[

		HSP3VarFunction (int)
		HSP3VarFunction (str)
		HSP3VarFunction (double)

		HSP3VarFunction (unicode) (*option)
		HSP3VarFunction (variant) (*option)
		HSP3VarFunction (COM automation) (*option)


HSP3vOCTv

	HSP3vOĆA̕@HSP3̃VXeg
	Ƃł܂B
	ł́AR̕@ɕĊg̊Tvƕ@ɂĉ܂B

	HSP3DLL Function

	ODLLƂHSP̐VK߂o^邱Ƃł܂B
	̒ŁAHSP3̃p[^[ϐȂǊeVXeɃANZX
	邱Ƃł܂B
	قƂǂ̏ꍇ́A̕@Ŋg邱Ƃł܂B
	HSP3DLL FunctionŊgłȂڂƂẮA֐VXeϐ̒ǉA
	ϐ^̒ǉȂǂׂVXe䂪Y܂B
	̊gsȂꍇɂ́AHSP3TypeFunctionyHSP3VarFunction
	𗘗pĊgKv܂B
	ڍׂɂẮAuHSP3DLL Function𗘗pߊgɂāv
	QƂĂB
	HSP3ɓĂgvOĈقƂǂ́Ǎ`ɂ쐬
	Ă܂B

	HSP3TypeFunction

	ߋyсAVXeϐA֐g܂B
	PHSP3TypeFunctionɂAPFunctionType蓖Ă܂B
	PHSP3TypeFunctionɂ́A0`0xffffffff܂ł̃TuIDU
	L[[h`邱Ƃł܂B
	HSPsɁAo^ꂽL[[hoHSP3TypeFunction
	Ăяo邱ƂɂȂ܂B
	HSP3TypeFunctiońAAIAߎsAlQƎA
	HSPCxgƂɃR[obN֐ݒ肷邱Ƃł܂B
	ꂼ̃R[obN֐̓ŁATuID̏Ȃǂƍ킹Ȃ
	@\s悤ɍ쐬Kv܂B
	HSP2܂ł́AP̃L[[h()ƂɂP̊֐pӂĂ܂A
	HSP3́AHSP3TypeFunctionƂɊ֐pӂ邾ōςނ悤
	Ȃ܂B
	FunctionTypéA܂ɃJeS𕪂邽߂̔ԍƍlĉB
	̖ʂAVXeϐA֐A߂ƂɕʂFunctionTypeU
	Ƃ𐄏Ă܂B
	FunctionTypéAgvOCo^ꂽԂ16lU
	܂BFunctionTypéA8192܂œo^邱Ƃł܂B

	HSP3VarFunction

	ϐɊi[邽߂̌^g܂B
	PHSP3VarFunctionɂAPVarType蓖Ă܂B
	PHSP3VarFunctiońAlۑ邽߂̃ǗAe퉉ZA
	^̕ϊAz̊ǗȂǂsȂKv܂B
	VarTypéAFunctionTypeƂ͈ႤlƂƂɒӂĂB
	WŒ񋟂ĂA(int)A(double)A(string)l
	dg݂ōĂ܂BWŗp^CvɂẮATvƂ
	\[XR[h񋟂܂B


HSP3DLL Function𗘗pߊgɂ

	HSP3.0ł́AyȖߊg̎iƂāAODLLRɌĂяo@\
	Ă܂B́AWIN32APIHSP2.5ȍ~̃vOCĂяo߂
	ʂĂ܂AȊOɂHSP3p̊gƂċ@\񋟂
	Ƃ\łB
	DLLĂяóAȉ̂悤ɒ`Ďs邱Ƃ\łB

		:
		#uselib "a.dll"			; "a.dll"gp
		#func newfunc newfunc pexinfo	; newfunc߂o^
		newfunc	1,2,3			; V߂s

	̗ł́AunewfuncvƂāua.dllvGNX|[gꂽ֐
	newfunc߂Ƃēo^AĂяoĂ܂B
	Ăяo鑤newfunc֐ł́A

	#define EXPORT extern "C" __declspec (dllexport)	// VC++̏ꍇ

	EXPORT BOOL WINAPI newfunc( HSPEXINFO *hei )
	{
		int p1,p2,p3;
		p1 = hei->HspFunc_prm_getdi(0);	// p[^1:
		p2 = hei->HspFunc_prm_getdi(0);	// p[^2:
		p3 = hei->HspFunc_prm_getdi(0);	// p[^3:
		return 0;
	}

	̂悤Ȍ`ŁAڃp[^[擾āACӂ̏sȂƂł܂B
	̕@́AHSP2.61ɂvOCK$202Ɠ̂ɂ܂B
	HSPEXINFO\̂ɂ邷ׂĂ̊֐A𗘗p邱Ƃł邽߁A
	yɖ߂ǉiƂĂB
	̕@́A܂ł߂giƂėpӂĂ̂łB
	֐VXeϐ̒ǉAϐ^̒ǉȂǂׂVXe
	sȂꍇɂ́A]ʂHSP3TypeFunctionyHSP3VarFunctionɂ
	gKv܂B


^CvIDɂ

	HSP3ł́Al╶ȂǈقȂ^߂Ƀ^CvIDgĔʂ
	sȂĂ܂B
	ϐɊi[l̃^CvƂĎgpID͈ȉ̒ʂłB

		#define HSPVAR_FLAG_STR 2	// SJIS(str)
		#define HSPVAR_FLAG_DOUBLE 3	// 64bit(double)
		#define HSPVAR_FLAG_INT 4	// 32bit(int)

	ȊO̒ĺAgꂽVarTypeƂĈ܂B
	vOCŗpp[^[́A̒lWI
	Ƃł܂B܂AvOC̊֐ԂlƂẴ^Cv
	w肷邱Ƃł܂B
	́AC`(I[R[h0tꂽ8bit̗)œ{ShiftJIS
	R[hŊi[Ă̂ŒӂĂB

	^CvID́A^ȊOHSP3TypeFunctioñR[ĥƂĂ
	p܂B(FunctionTypeƂĂ΂܂)

		#define TYPE_INTCMD 8		// 
		#define TYPE_EXTCMD 9		// GUI
		#define TYPE_EXTSYSVAR 10	// GUIVXeϐ
		#define TYPE_CMPCMD 11		// (if/else)
		#define TYPE_MODCMD 12		// W[
		#define TYPE_INTFUNC 13		// ֐
		#define TYPE_SYSVAR 14		// VXeϐ
		#define TYPE_PROGCMD 15		// (vO)

	^CvID16ȍ~́AvOCŊgꂽ^CvƂȂ܂B
	̃^CvID́AvOCł͂قǈӎKv͂܂B
	̃^CvIDuAL[[h`邱ƂŁA
	̂̂uAL[[hύX邱Ƃ\ɂȂ܂B
	R}hvvgpHSP(R\[[h)ł́AGUĨ^Cv
	ɂȂ܂B


HSP3TypeFunction̏

	HSP3TypeFunctionvOĆAC̊֐`(stdcall)ɂČĂяo܂B
	DLLƂČĂяoꍇɂ́AHSP̃\[XɈȉ̃vvZbT߂Lq
	ĂB

	#regcmd "֐","DLLt@C",ϐ^g

	ɂAHSP^CNɎw肳ꂽDLLt@C̏֐
	Ă΂邱ƂɂȂ܂B
	֐́ADLLGNX|[gꂽO𐳊mɎw肵Ȃ
	Ȃ܂BVC++GNX|[gꍇɂ́A擪Ɂu_vAŌ
	u@4vt̂ŁA܂߂OLq܂B
	(VC++ȊÕRpCō쐬ꂽDLL̏ꍇ́AGNX|[g̃[
	قȂ܂Bڂ́Aꂼ̊̎QƂĂB)
	ϐ^ǵAHSP3VarFunctiongꍇɎw肷p[^[łB
	HSP3TypeFunction̂݊gꍇ́A0܂͏ȗč\܂B
	HSP3VarFunctiongꍇ́Agw肷Kv܂B

	ĂTvł́Auhpi3sample.dllv́uhsp3cmdinitvƂ
	֐o^Ă܂Ȁꍇ́A

		:
		#regcmd "_hsp3cmdinit@4","hpi3sample.dll"

	̂悤ɂȂ܂B
	֐́Aȉ̃p[^[󂯎܂B
	(EXPORT}ŃAVC++̂ݎgp\łB̊ł́AʓrGNX|[g
	邽߂̎wǉKv܂B)

	EXPORT void WINAPI hsp3cmdinit( HSP3TYPEINFO *info )
	{
	//		vOC (sEIo^܂)
	//
	hsp3sdk_init( info );			// SDK̏(ŏɍsȂĉ)
	info->cmdfunc = cmdfunc;		// s֐(cmdfunc)̓o^
	info->reffunc = reffunc;		// QƊ֐(reffunc)̓o^
	info->termfunc = termfunc;		// I֐(termfunc)̓o^
	}

	֐ł́Aŏɒ񋟂HSP3TYPEINFO\̂ɓK؂Ȋ֐w肷
	ƂɂvOC@\LɂȂ܂B
	HSP3TYPEINFO\̂́Aȉ̂悤ȍ\ɂȂĂ܂B

	typedef struct {
		//	^Ƃ̏
		//	(*̍ڂ́AeAvP[VŐݒ肳܂)
		//
		short type;							// *^^Cvl
		short option;						// *IvV
		HSPCTX *hspctx;						// *HSP Context\̂ւ̃|C^
		HSPEXINFO *hspexinfo;				// *HSPEXINFO\̂ւ̃|C^

		//	t@NV
		//
		int (* cmdfunc) (int);				// R}h󂯎t@NV
		void *(* reffunc) (int *,int);		// QƎ󂯎t@NV
		int (* termfunc) (int);				// I󂯎t@NV

		// CxgR[obNt@NV
		//
		int (* msgfunc) (int,int,int);				// WindowbZ[WR[obN
		int (* eventfunc) (int,int,int,void *);		// HSPCxgR[obN

	} HSP3TYPEINFO;

	hsp3sdk_init́AvOC쐬T|[g֐Ă
	uhsp3plugin.cppvɊ܂܂Ă܂Bhsp3plugin.cppgpꍇ́A
	ŏɌĂяoĂĂB
	̌As֐(cmdfunc)AQƊ֐(reffunc)AI֐(termfunc)
	\̂ɑĂB(KvȂ̂́AKv܂B)
	KvɉāACxgR[obN֐(eventfunc)o^邱Ƃ
	ł܂BCxgR[obN֐𗘗pꍇ́Aʓroptionw
	Kv܂Bڂ́ACxgR[obN֐ɂĂ̐
	QƂĂB
	I֐(termfunc)́AtHSP^C̏IɌĂяo֐
	w肵܂BvOCŊmۂ\[X́AKIɉ悤
	ĂB

	ȏŏ͊܂B
	ȍ~́Asɓo^L[[hoꍇɓo^Ă
	֐Ăяo邱ƂɂȂ܂B
	L[[h̓o^́AXNvgňȉ̂悤ɋLq܂B

	#cmd VKL[[h TuID

	#cmd́AK#regcmďɏKv܂B
	ȉ́ATvɂłB

		:
		#cmd newcmd $000
		#cmd newcmd2 $001
		#cmd newcmd3 $002

	̗ł́AunewcmdvƂL[[hTuID0ƂāA
	unewcmd2vƂL[[hTuID1A
	unewcmd3vƂL[[hTuID2Ƃēo^܂B

	cmdfunc(R}h󂯎t@NV)́Ao^ꂽL[[hHSP
	߂ƂĎsꂽ̏[`ƂȂ܂B
	łPȁAR}h󂯎t@NV͈ȉ̂悤Ȃ̂łB

	static int cmdfunc( int cmd )
	{
		//		s (ߎsɌĂ΂܂)
		//
		code_next();							// ̃R[h擾(ŏɕKKvł)

		switch( cmd ) {							// TuR}hƂ̕

		case 0x00:								// newcmd
			:
			TuID0̎̏
			:
			break;

		default:
			puterror( HSPERR_UNSUPPORTED_FUNCTION );
		}
		return RUNMODE_RUN;
	}

	cmdfuncɂ́ATuIDƂēn܂B
	ɉswitchŕċLqĂ̂WI
	쐬@ƂȂ܂B
	ԒĺAȉ̒I邱Ƃł܂B

		RUNMODE_RUN	// sp
		RUNMODE_WAIT	// wait
		RUNMODE_AWAIT	// await
		RUNMODE_STOP	// s~
		RUNMODE_END	// sI

	reffunc(QƎ󂯎t@NV)́Ao^ꂽL[[h
	HSP̃p[^[Ɏ̈ꕔƂďȍsȂ܂B
	QƎ󂯎t@NV́ATuID̏󂯎܂A
	ʂƂĉ炩̒lԂKv܂B
	QƎ󂯎t@NVł́AVXeϐƊ֐̂ǂ炩
	쐬邱Ƃł܂B
	TuIDƂɌ߂ꂽlԂ̂VXeϐƂāA
	܂JbR̃p[^[擾ĂƂɌʂԂ̂
	֐ƂĈƂł܂B

	łPȁAQƎ󂯎t@NV͈ȉ̂悤Ȃ̂łB

	static int ref_ival;		// Ԓl̂߂̕ϐ̈

	static void *reffunc( int *type_res, int cmd )
	{
	//		VXeϐ̎s (l̎QƎɌĂ΂܂)
	//
	switch( cmd ) {					// TuR}hƂ̕

	case 0x00:					// newcmd

		ref_ival = 123;				// Ԓlivalɐݒ
		break;

	default:
		puterror( HSPERR_UNSUPPORTED_FUNCTION );
	}

	*type_res = HSPVAR_FLAG_INT;			// Ԓl̃^Cv𐮐Ɏw肷
	return (void *)&ref_ival;
	}

	̗ł́AVXeϐƂăTuID0(newcmd)Ă܂B
	TuID0ꂽꍇɂ́A123Ƃl𐮐l(HSPVAR_FLAG_INT)
	ƂĕԂ܂B
	֐Ƃďꍇ́Aȉ̂悤ɂȂ܂B

	static int ref_ival;		// Ԓl̂߂̕ϐ̈

	static void *reffunc( int *type_res, int cmd )
	{
	//		֐̎s (l̎QƎɌĂ΂܂)
	//
	//			'('Ŏn܂邩𒲂ׂ
	//
	if ( *type != TYPE_MARK ) throw HSPERR_INVALID_FUNCPARAM;
	if ( *val != '(' ) throw HSPERR_INVALID_FUNCPARAM;
	code_next();


	switch( cmd ) {				// TuR}hƂ̕

	case 0x00:				// newcmd

		p1 = code_geti();		// l擾(ftHgȂ)
		ref_ival = p1 * 2;		// Ԓlivalɐݒ
		break;

	default:
		puterror( HSPERR_UNSUPPORTED_FUNCTION );
	}

	//			')'ŏI邩𒲂ׂ
	//
	if ( *type != TYPE_MARK ) throw HSPERR_INVALID_FUNCPARAM;
	if ( *val != ')' ) throw HSPERR_INVALID_FUNCPARAM;
	code_next();

	*type_res = HSPVAR_FLAG_INT;		// Ԓl̃^Cv𐮐Ɏw肷
	return (void *)&ref_ival;
	}

	̗ł{Iȗ͓łB
	VXeϐƂ̈Ⴂ́AɗL[[hu(vJbR
	ȂĂ邩`FbN镔ƁAŌオu)vJbR
	ȂĂ邩̃`FbNBāAp[^[擾Ă
	ƂɂȂ܂Bp[^[̎擾@́AߎsɎgp
	@Ƃ܂̂ɂȂ܂B


p[^[̎擾

	߂֐̒ŁAp[^[擾邱ƂłB
	uhsp3sdk_initvĂ΂ĂԂł΁Aȉ̊֐ɂ
	p[^[擾邱Ƃł܂B
	G[ꍇ́A̎_Ŏsf܂B
	(HSP2̃vOCSDKł́Ap[^[擾̍ŌɃG[`FbN
	sȂKv܂AHSP3ł͓ŗOɂG[gbv
	sȂĂ邽߃`FbN̕Kv͂܂B)

	int code_getdi( int defval );

	l擾܂Bp[^[ȗꂽꍇ́Adefval
	ftHg̒lƂĕԂ܂B
	(double)̏ꍇ́Aɕϊꂽ̂擾܂B
	ȊǑ^̓G[ɂȂ܂B

	int code_geti( void );

	code_getdiƓłAftHgl͂܂B
	p[^[ȗꂽꍇ̓G[ƂȂ܂B

	double code_getdd( double defstr );

	l擾܂Bp[^[ȗꂽꍇ́Adefval
	ftHg̒lƂĕԂ܂B
	(int)̏ꍇ́Aɕϊꂽ̂擾܂B
	ȊǑ^̓G[ɂȂ܂B

	double code_getd( void );

	code_getddƓłAftHgl͂܂B
	p[^[ȗꂽꍇ̓G[ƂȂ܂B

	char *code_getds( char *defstr );

	̃|C^擾܂Bp[^[ȗꂽꍇ́A
	defstrftHgƂĕԂ܂B
	ȊǑ^̓G[ɂȂ܂B
	œꂽ|C^́AɃp[^[擾܂ł
	Lł͂܂B̎擾ȍ~ɁAʂȃp[^[
	(񂾂łȂll܂)擾ꍇɂ́A
	f[^j󂳂܂̂ŁAKp[^[擾ŕۑ
	悤ɂĂB
	܂A̎擾͔ɒf[^ԂĂ邱Ƃ
	܂̂ŁARs[ꍇɂ͕KvȒɐ邩A
	TCY܂邾̃mۂ悤ɂĂB

	char *code_gets( void );

	code_getdsƓłAftHgl͂܂B
	p[^[ȗꂽꍇ̓G[ƂȂ܂B

	unsigned short *code_getlb( void );

	xXNvg̃|C^擾܂B
	Ŏ擾x́AWvTu[`R[
	ΏۂƂĈƂł܂B
	xȊOw肳ꂽꍇ̓G[ɂȂ܂B

	APTR code_getva( PVal **pval );

	p[^[ƂĎw肳ꂽϐPVal|C^ƁAAPTR
	|C^擾܂B
	ϐȊOw肳ꂽꍇ̓G[ɂȂ܂B
	APTR|C^́Azvf̒lA
	PVal|C^́Aϐ̏񂪊i[Ăւ
	|C^ƂȂ܂B
	擾ϐ̌^́APVal->flagŒׂ邱Ƃł܂B
	擾ϐɑsȂꍇɂ́Acode_setvgp܂B

	void code_setva( PVal *pval, APTR aptr, int type, void *ptr );

	APTRPVal̃|C^ƂɁAϐɒl܂B
	typeɑľ^(HSPVAR_FLAG_*)Aptrɒli[Ă
	|C^w肵܂B
	ϐɊi[Ă^A^ƈႤꍇɂ́A
	^ɏĂ܂B

	int code_getprm( void );

	p[^[P擾܂B
	p[^[̌^͖₢܂B̊֐̖߂lɂA擾
	󋵂mF邱Ƃł܂B߂l͈ȉ̂ꂩɂȂ܂B

	#define PARAM_OK 0		// Ɏ擾
	#define PARAM_SPLIT -1		// Ɏ擾(*)
	#define PARAM_END -2		// 
	#define PARAM_DEFAULT -3	// ȗĂ
	#define PARAM_ENDSPLIT -4	// ')'

	(*)PARAM_SPLIT́APARAM_OKƓl̈ӖłAɎp[^[
	   PARAM_ENDSPLIT(JbȐI)ł邱ƂĂ܂B
	   PARAM_SPLIT́AJbR̃p[^[擾ꍇȊOł
	   Ԃ܂B܂AŌ̃p[^[ȗl(PARAM_DEFAULT)
	   ̏ꍇ́Ãp[^[擾ꍇɂ́APARAM_SPLITԂ
	   PARAM_ENDSPLIT̂ŒӂĂB

	PARAM_OKAPARAM_SPLITԂꍇɂ́Aϐmpvalp[^[
	eϐƂč쐬܂B
	(ȊO̖߂lł́Ampval͖ɂȂ܂B)
	ۂɂ́Aumpval->ptvp[^[̒li[Ă|C^A
	umpval->flagvp[^[̌^(HSPVAR_FLAG_*)ɂȂ܂B
	(p[^[Ƃĕϐw肳ĂꍇłAmpval͕ϐ̂̂
	|C^Ƃ͂Ȃ܂Bmpval͏ɁAʂ̒lꂽe|
	̕ϐƂȂ܂)

	PARAM_DEFAULTԂꍇɂ́Ap[^[ȗĂ邱Ƃ
	܂B
	擾ׂp[^[ꍇ́APARAM_END܂́APARAM_ENDSPLIT
	Ԃ܂BPARAM_ENDSPLIT́AJbR̃p[^[IƂ
	lɂȂ܂B

	void *code_getv( void );

	HSPEXINFOɗpӂꂽver2.61݊$202KĂяop̊֐łB
	$202KĂяoł́APVal|C^擾邽߂ɁAmpval|C^
	QƂ܂Bcode_getv֐́Ampval|C^XVāA擾ꂽ
	ϐ̃|C^܂B

	void code_next( void );

	̒ԃR[h擾܂B
	擾ꂽp[^[́A*typeA*valɔf܂B
	*typéAuTYPE_*v̒lA*val͓elɂȂ܂B
	̖߂́Aʏp[^[擾ŎgpKv͂܂B
	ƎɁAԃR[hǂݎďsȂ悤ȓȏʂł̂
	gpĂB

	char *code_getns( void );
	char *code_getnds( char *defstr );

	HSP3.5ǉꂽڂłB
	p[^[擾code_gets/code_getdsƊ{Iȋ@\͕ς܂񂪁A
	^Cunicode(hsp3utf)ꍇAHSP̌`łUTF-8̂̕܂܎擾܂B
	(ʏcode_gets/code_getdśAunicode(hsp3utf)łĂʏHSPƓl̕R[h(SJIS)ɕϊ܂B
	unicodełɑΉvOC쐬ꍇɁAcode_getns/code_getnds
	gpB
	(ĂяoHSP^Cunicodeǂ𔻕ʂɂ́A
	HSPCTX\̂hspstatQƂĂB)

	------------------------------------------------------------------------
	p[^[̎擾@́AHSP2.6SDKō̗pꂽ$202^Cv
	gpĂHSPEXINFO\̂ƌ݊܂B
	HSP3łlɁAHSPEXINFO\̂gpĂAȉ̂悤ȓe
	ȂĂ܂B

	typedef struct HSPEXINFO
	{
	//		HSP internal info data (2.6)
	//
	short ver;		// Version Code
	short min;		// Minor Version
	//
	int *er;		// Not Use
	char *pstr;		// String Buffer (master)
	char *stmp;		// String Buffer (sub)
	PVal **mpval;		// Master PVAL
	//
	int *actscr;		// Active Window ID
	int *nptype;		// Next Parameter Type
	int *npval;			// Next Parameter Value
	int *strsize;		// StrSize Buffer
	char *refstr;		// RefStr Buffer
	//
	void *(*HspFunc_prm_getv)( void );
	int (*HspFunc_prm_geti)( void );
	int (*HspFunc_prm_getdi)( const int defval );
	char *(*HspFunc_prm_gets)( void );
	char *(*HspFunc_prm_getds)( const char *defstr );
	int (*HspFunc_val_realloc)( PVal *pv, int size, int mode );
	int (*HspFunc_fread)( char *fname, void *readmem, int rlen, int seekofs );
	int (*HspFunc_fsize)( char *fname );
	void *(*HspFunc_getbmscr)( int wid );
	int (*HspFunc_getobj)( int wid, int id, void *inf );
	int (*HspFunc_setobj)( int wid, int id, const void *inf );

	//		HSP internal info data (3.0)
	//
	int *npexflg;	// Next Parameter ExFlg
	void *hspctx;	// HSP context ptr

	//		Enhanced data (3.0)
	//
	int (*HspFunc_addobj)( int wid );
	void (*HspFunc_puterror)( HSPERROR error );
	HspVarProc *(*HspFunc_getproc)( int type );
	HspVarProc *(*HspFunc_seekproc)( const char *name );

	void (*HspFunc_prm_next)( void );
	int (*HspFunc_prm_get)( void );
	double (*HspFunc_prm_getd)( void );
	double (*HspFunc_prm_getdd)( double defval );
	unsigned short *(*HspFunc_prm_getlb)( void );
	PVal *(*HspFunc_prm_getpval)( void );
	APTR (*HspFunc_prm_getva)( PVal **pval );
	void (*HspFunc_prm_setva)( PVal *pval, APTR aptr, int type, const void *ptr );
	char *(*HspFunc_malloc)( int size );
	void (*HspFunc_free)( void *ptr );
	char *(*HspFunc_expand)( char *ptr, int size );
	IRQDAT *(*HspFunc_addirq)( void );
	int (*HspFunc_hspevent)( int event, int prm1, int prm2, void *prm3 );
	void (*HspFunc_registvar)( int flag, HSPVAR_COREFUNC func );
	void (*HspFunc_setpc)( const unsigned short *pc );
	void (*HspFunc_call)( const unsigned short *pc );
	void (*HspFunc_mref)( PVal *pval, int prm );

	void (*HspFunc_dim)( PVal *pval, int flag, int len0, int len1, int len2, int len3, int len4 );
	void (*HspFunc_redim)( PVal *pval, int lenid, int len );
	void (*HspFunc_array)( PVal *pval, int offset );

	//		Enhanced data (3.1)
	//
	char *(*HspFunc_varname)( int id );
	int (*HspFunc_seekvar)( const char *name );

	//		Enhanced data (3.5)
	//
	char *(*HspFunc_prm_getns)(void);
	char *(*HspFunc_prm_getnds)(const char *defstr);

	} HSPEXINFO;

	HSP2.6gꂽA폜ꂽtB[h܂A
	p[^[̎擾ȂǑ̓_œl̓eɂȂĂ܂B
	HSPEXINFO\̂́Ahsp3plugin.h̒exinfoƂOŒ`Ă܂B
	vOC̒ŁAuexinfo->HspFunc_prm_geti();v̂悤ɋLqĂ
	肠܂B̍ŐĂ֐(code_geti)́AexinfoY
	֐Ăяo߂̃}NɂȂĂ邾łB
	ߋɍ쐬HSP2.6p̃vOC3.0pɈڐAꍇɂ́A̓_
	ӂ΂xƂyƎv܂B
	------------------------------------------------------------------------


̎擾Ɛݒ

	HSP̃\[XɃANZX邽߂ɁAȉ̊֐𗘗p邱Ƃł܂B

	void *getbmscr( int wid );

	widŎw肵EChDID̏Ԃ܂B
	EChEIDsȏꍇ̓G[O܂B
	HSP3̕WGUIgpĂꍇ́ABMSCR\̂ւ̃|C^ɂȂ܂B
	BMSCR\̂ɂĂ̏ڍׂ́AʍQƂĂB
	܂Ȃ݂EChDID́Aactive_window}NɂĎ擾
	Ƃł܂B

	int getobj( int wid, int id, void *inf );

	widŎw肵EChDIDɔzuĂAidŎw肳ꂽԍ
	IuWFNg擾܂B
	EChEIDAIuWFNgIDsȏꍇ̓G[O܂B
	擾ꂽf[^́AinfŎw肳ꂽ|C^ɃRs[܂B
	HSP3̕WGUIgpĂꍇ́AinfɂHSPOBJINFO\̂̓e
	Rs[邱ƂɂȂ܂B
	HSPOBJINFO\̂ɂẮAIuWFNgɂĂ̍ڂQ
	ĂB
	ԒĺAɏIꍇ0ɁAȊO̒l̓G[܂B

	int setobj( int wid, int id, void *inf );

	widŎw肵EChDIDɔzuĂAidŎw肳ꂽԍ
	IuWFNgݒ肵܂B
	EChEIDAIuWFNgIDsȏꍇ̓G[O܂B
	infŎw肳ꂽ|C^f[^ɃRs[܂B
	HSP3̕WGUIgpĂꍇ́AinfɂHSPOBJINFO\̂̓e
	Rs[邱ƂɂȂ܂B
	HSPOBJINFO\̂ɂẮAIuWFNgɂĂ̍ڂQ
	ĂB
	ԒĺAɏIꍇ0ɁAȊO̒l̓G[܂B

	int addobj( int wid );

	widŎw肵EChDIDɁAVIuWFNgID𐶐ĕԂ܂B
	vOCŁAƎ̃IuWFNg𐶐ꍇɎgp܂B
	̊֐ŃIuWFNgID𐶐AKsetobjŐݒ
	悤ɂĂB

	HspVarProc *HspFunc_getproc( int type );

	typeŎw肳ꂽ^(HSPVAR_FLAG_*)邽߂HspVarProc\
	|C^Ԃ܂B

	HspVarProc *seekproc( char *name );

	nameŎw肳ꂽ^邽߂HspVarProc\̃|C^Ԃ܂B
	naméAꂼ̌^Őݒ肳Ă^(int,str,double)𕶎
	w肵܂BɂAvOCŊgꂽ^܂߂āA
	sȂ߂̏擾Aݒ肷邱Ƃł܂B

	void *hspmalloc( int size );
	void hspfree( void *ptr );
	char *hspexpand( char *ptr, int size );

	hspmallocƁAhspfreeHSPŊǗ郁}l[W[oR
	̊mۂƉsȂ܂B(malloc/freeƓl̎głB)
	hspmallocƁAhspfree͏ȂTCY(64byte)łΔɍɓ
	܂B܂AHSPIɂׂẴ͎Iɉ܂B
	hspexpand́AɊmۍς݂̃傫ȃTCYōĊmۂ܂B
	܂܂ŕێĂe͕ύX܂B

	int code_event( int event, int prm1, int prm2, void *prm3 );

	HSPCxg𔭐܂B
	ڂ́AHSPCxgɂĂQƂĂB

	void puterror( HSPERROR err );

	HSP̃G[𔭐܂B
	errɎw肷G[R[h́Ahsp3plugin.hŒ`Ă܂B
	̊֐͎sꂽA߂Ă܂̂ŒӂĂB

	IRQDAT *addirq( void );

	荞ݗvǉ܂B
	oncmdƓlWindows̃EChDbZ[Wɑ΂銄荞݂Ǝ
	ǉ邱Ƃł܂B

	void registvar( int flag, HSPVAR_COREFUNC func );

	Xg[WRAt@NV(HspVarProc)o^܂B
	flagɂ́Ã^CvIDVKID(-1)w肵A
	funcɏ֐(HSPVAR_COREFUNC)̃AhXnĉB
	Xg[WRAt@NV̓o^́AKHSP3TypeFunction̏
	sȂKv܂B

	void code_setpc( unsigned short *pc );

	pcŎw肵xփWv(goto)sȂ܂B
	x́Acode_getlbŎ擾ꂽlgp܂B

	void code_call( unsigned short *pc );

	pcŎw肵xփTu[`R[(gosub)sȂ܂B
	x́Acode_getlbŎ擾ꂽlgp܂B


	void (*HspFunc_dim)( PVal *pval, int flag, int len0, int len1, int len2, int len3, int len4 );

	pvalŎw肵ϐw肵zvfŏ܂B
	dim߂Ɠl̓ɂȂ܂B
	len1`len4e̍ő吔ɂȂ܂BgpȂ0ɂȂ܂B
	len0́APvfσTCY̏ꍇ̏TCYw肵܂B
	(usdim a,256v256ɂ鐔lłB)
	flagŏ^w肵܂B

	void (*HspFunc_array)( PVal *pval, int offset );

	w肵zvfwpval쐬邽߂Ɏgp܂B
	ȉ̎菇ŁAe̗vfCӂɐݒ肷邱Ƃ\łB

		 HspVarCoreReset( pval );// z|C^Zbg
		 HspFunc_array( pval, 0 );// 1
		 HspFunc_array( pval, 0 );// 2
		 HspFunc_array( pval, 0 );// 3
		 HspFunc_array( pval, 0 );// 4

	HspFunc_arrayɂč쐬ꂽPvaĺApval->offsetɔzvf
	ANZX邽߂̃ItZbgl(APTR)ݒ肳܂B

	void (*HspFunc_redim)( PVal *pval, int lenid, int len );

	w肵ϐ̔zg܂B
	pvalϐ́Aw肵lenid(1`4)ɑ΂len̑傫Ɋg܂B

	char *(*HspFunc_varname)( int id );

	w肵ID̕ϐ擾܂B
	ID́A0n܂ϐID̍ő(HSPHED\̂max_valo)LłB
	̊֐́AHSPIuWFNgɕϐ񂪊i[Ăꍇɂ̂
	擾邱Ƃł܂BȊȌꍇ́AɁu""vԂ܂B
	(ϐ́A#cmpopt߂ɂݒ肷邱Ƃ\łB)

	int (*HspFunc_seekvar)( const char *name );

	w肵ϐϐID擾܂B
	ID́A0n܂ϐID̍ő(HSPHED\̂max_valo)Ă܂B
	YϐȂꍇ́A-1Ԃ܂B
	̊֐́AHSPIuWFNgɕϐ񂪊i[Ăꍇɂ̂
	擾邱Ƃł܂BȊȌꍇ́A-1Ԃ܂B
	(ϐ́A#cmpopt߂ɂݒ肷邱Ƃ\łB)


BMSCR\̂ɂ

	BMSCR\̂́AEChDɊւׂĊ܂ł܂B
	EChD̃TCYAHWNDnhfoCXReLXg̏Ȃ
	EChDɊւقƂǂ̏𓾂邱Ƃł܂B

	BMSCR\̂́AHSP2.61܂łSDKŎgpĂ̍\̂
	̕Ō݊܂B
	BMSCR\̂QƂē삷vÓÂ܂HSP3BMSCR\
	łgp邱Ƃł܂B݊ێłȂɂẮA
	OύXĂ邩AtB[h폜Ă܂B
	܂AHSP3ǉĂ鍀ڂ݂܂B

	HSP2̑傫ȕύX_́AIuWFNg̏tB[h
	HSPOBJINFO\̃x[XɂȂĂƂłB
	IuWFNg̏ɂẮAgetobj/setobjgp悤ɂĉB

	typedef struct BMSCR
	{
		//
		//		Window data structure
		//
		int		flag;				// used flag
		int		sx;					// X-size
		int		sy;					// Y-size
		int		palmode;			// palmode
		HDC		hdc;				// buffer HDC
		BYTE	*pBit;				// bitmap pointer
		BITMAPINFOHEADER *pbi;		// infoheader
		HBITMAP	dib;				// bitmap handle(DIB)
		HBITMAP	old;				// bitmap handle(OLD)
		RGBQUAD *pal;				// palette table
		HPALETTE hpal;				// palette handle
		HPALETTE holdpal;			// palette handle (old)
		int		pals;				// palette entries
		HWND	hwnd;				// window handle
		HINSTANCE hInst;			// Instance of program
		int		infsize;			// *pbi alloc memory size
		int		bmpsize;			// *pBit alloc memory size

		//		Window object setting
		//
		int		type;				// setting type
		int		wid;				// window ID
		short	fl_dispw;			// display window flag
		short	fl_udraw;			// update draw window
		int		wx,wy,wchg;			// actual window size x,y
		int		viewx,viewy;		// buffer view point x,y
		int		lx,ly;				// buffer view size x,y
		int		cx,cy;				// object cursor x,y
		int		ox,oy,py;			// object size x,y,py
		int		texty;				// text Y-axis size
		int		gx,gy,gmode;		// gcopy size
		HBRUSH	hbr;				// BRUSH handle
		HPEN	hpn;				// PEN handle
		HFONT	hfont;				// FONT handle
		HFONT	holdfon;			// FONT handle (old)
		COLORREF color;				// text color code
		int		textspeed;			// slow text speed
		int		cx2,cy2;			// slow text cursor x,y
		int		tex,tey;			// slow text limit x,y
		char	*prtmes;			// slow message ptr
		int		focflg;				// focus set flag
		int		objmode;			// object set mode

		LOGFONT	*logfont;			// logical font
		int		logopt[14];			// dummy padding

		int		style;				// extra window style
		int		gfrate;				// halftone copy rate
		int		tabmove;			// object TAB move mode
		int		sx2;				// actual bitmap X size
		SIZE	printsize;			// print,mes extent size

		//		Class depend data
		//
		int		objstyle;					// objects style
		HSPOBJINFO *mem_obj;				// Window objects
		int objmax;							// Max number of obj
		int objlimit;						// Limit number of obj
		short savepos[BMSCR_SAVEPOS_MAX];	// saved position
		void *master_hspwnd;				// Parent hspwnd class
		short	palcolor;					// Palette color code
		short	textstyle;					// Extra text style
		short	framesx, framesy;			// Window frame xy-size

		int		imgbtn;						// Custom Button Flag (-1=none)
		short	btn_x1, btn_y1;				// Custom Button Image X,Y
		short	btn_x2, btn_y2;				// Custom Button Image X,Y (press)
		short	btn_x3, btn_y3;				// Custom Button Image X,Y (mouse over)
		short	divx, divy;					// Divide value for CEL
		short	divsx, divsy;				// CEL size
		short	celofsx, celofsy;			// CEL center offset

		COLORREF objcolor;					// object color code
		int		fonteff_size;				// effect size for font

		int		vp_flag;					// Viewport enable flag (0=none)
		float	vp_matrix[16];				// Viewport matrix

	} BMSCR;

	etB[h̏ڍׂ́Aȉ̒ʂłB

	int		flag;			// used flag

	BMSCRǗʂgpĂ邩ǂ̃tOłB

		#define BMSCR_FLAG_NOUSE	0
		#define BMSCR_FLAG_INUSE	1

	̂ꂩݒ肳Ă܂B

	int		sx;			// X-size
	int		sy;			// Y-size
	int		sx2;			// actual bitmap X size
	int		palmode;		// palmode

	ʂTCYi[Ă܂B
	sx,syX,ỸhbgɂȂ܂B
	sx2́Ãrbg}bvTCY(hbgł͂܂)
	oCgPʂŊi[܂B
	palmode͈ȉ̂ꂩݒ肳Ă܂B

		#define BMSCR_PALMODE_FULLCOLOR	0
		#define BMSCR_PALMODE_PALETTECOLOR	1

	HDC		hdc;			// buffer HDC

	ʂ̃foCXReLXgi[Ă܂B
	̃nhgGDIt@NVŉʂɕ`悷邱Ƃ\łB
	ӂȂ΂ȂȂ̂́A̓̃rbg}bvւ
	foCXReLXgƂƂłBɕ`ĂAۂ
	EChDʏł͉̕ωN܂Bۂ̃EChDʂ
	ύX𔽉f邽߂ɂ́AHSPredraw߂Ȃǂgpčĕ`
	sȂAGetDC߂Ŏۂ̃EChDւ̃foCXReLXg
	擾ĕ`悷Kv܂B

	BYTE	*pBit;				// bitmap pointer

	ʂ̃rbg}bvf[^i[Ă郁̐擪AhXłB
	̃|C^gĒځAʂɃf[^ނƂ\łB
	Ƀf[^𒼐ڏݏꍇ́AFXȒӂKvłBڂ́A
	urbg}bvʂւ̒ڏ݁vQƂĂB

	BITMAPINFOHEADER *pbi;		// infoheader
	HBITMAP	dib;				// bitmap handle(DIB)
	HBITMAP	old;				// bitmap handle(OLD)

	ʃf[^Ǘrbg}bvɂĂ̏łB
	oldóA[NɎgpĂ邾Ȃ̂œɌ܂l͊i[
	܂B

	RGBQUAD *pal;				// palette table
	HPALETTE hpal;				// palette handle
	HPALETTE holdpal;			// palette handle (old)
	int		pals;			// palette entries

	ʂɓKpĂpbg̏łB
	holdpalóA[NɎgpĂ邾Ȃ̂œɌ܂l͊i[
	܂Bpbg̕ύX͂ȂׂHSP̖߂ōsȂ悤ɂāA
	̃o͎QƂɂƂǂ߂ĂĂB

	HWND	hwnd;				// window handle

	ʂ̕`ɂEChD̃nhłB

	HANDLE	hInst;				// Instance of program

	EChDǗvO߂̃CX^XłB

	int		infsize;		// *pbi alloc memory size
	int		bmpsize;		// *pBit alloc memory size

	ʃf[^̃gpʂ[NłB

	int		type;			// setting type

	ʂ̑܂B
	l̎e͈ȉ̒ʂłB

		#define HSPWND_TYPE_NONE 0
		#define HSPWND_TYPE_BUFFER 1
		#define HSPWND_TYPE_MAIN 2
		#define HSPWND_TYPE_BGSCR 3

	int		wid;			// window ID

	EChDID܂B

	short	fl_dispw;			// display window flag
	short	fl_udraw;			// update draw window

	ʂEChDƂĕ\Ă邩ǂA
	ʂ̍XVKvǂtOłB

	int		wx,wy,wchg;		// actual window size x,y
	int		viewx,viewy;		// buffer view point x,y
	int		lx,ly;			// buffer view size x,y

	XN[o[ɂăXN[\ȃEChDł́A
	\EChDTCYAʓ]錳WA]͈
	Ȃǂ܂B

	int		cx,cy;			// object cursor x,y

	Jg|WV܂B

	int		ox,oy,py;		// object size x,y,py

	objsize߂Ŏw肵IuWFNg̑傫܂B
	pyóAJg|WVY֑ۂ̃hbgɂȂ
	܂B

	int		texty;			// text Y-axis size

	ݑIĂ镶tHgỸTCY܂B

	int		gx,gy,gmode;		// gcopy size
	int		gfrate;			// halftone copy rate

	gmode߂Ŏw肵ʃRs[̃TCYƃ[h܂B
	gfratéAɂ摜Rs[̃[gi[܂B

	HBRUSH	hbr;				// BRUSH handle
	HPEN	hpn;				// PEN handle

	color߂Ŏw肵FɂuVƃyIuWFNg
	nhłB

	HFONT	hfont;				// FONT handle
	HFONT	holdfon;			// FONT handle (old)

	font߂Ŏw肵tHg̃IuWFNgnhłB
	holdfon̓[NpœɌ܂l͎܂B

	COLORREF color;			// text color code

	color߂Ŏw肵Ff[^܂B

	int		textspeed;		// slow text speed

	text߂Ŏw肵eLXg̕\Xs[h܂B

	int		cx2,cy2;		// slow text cursor x,y
	int		tex,tey;		// slow text limit x,y
	char	*prtmes;			// slow message ptr

	ƕ\邽߂̃[NłB

	int		focflg;				// focus set flag

	focflǵAtH[JX킹邽߂̈ꎞtOɎgp܂B
	̒ĺAŎgp邾Ȃ̂ŕύXȂŉB

	int		objmode;			// object set mode

	objmodéAobjmode߂Őݒ肳Ă郂[hi[܂B

	LOGFONT	*logfont;			// logical font (HSP3.6ȍ~)
	LOGFONT	logfont;			// logical font (HSP3.6ȑO)

	logfont͑Iꂽ_tHg̍\̂i[܂B
	HSP3.6ȑOLOGFONT\̂`Ă܂AHSP3.6ȍ~̓|C^ɕύXĂ܂B
	vOCł̍ڂ𑀍삷邱Ƃ͂قƂǂȂƎv܂AYꍇ͒ӂĂB
	HSP3.6ȍ~łApfBÖĂ邽ߏ]̍\̂TCŶɕύX͂Ȃ̂ŁA
	̕ύXɂÃoe󂯂邱Ƃ͂܂B

	int		style;				// extra window style

	EChDŗL̃X^C(screen߂Őݒ)i[܂B

	int		tabmove;			// object TAB move mode

	tabmodéA[TAB]L[ɂIuWFNgtH[JXړsȂǂ̃tOi[܂B

	SIZE	printsize;			// print,mes extent size

	printsizéAmesAprint߂ɂ\ꂽbZ[W̋`͈͂i[܂B
	(ginfo߂Ŏ擾\)

	int		objstyle;			// objects style

	IuWFNgɓKpX^Ci[܂B

	HSPOBJINFO *mem_obj;		// Window objects
	int objmax;					// Max number of obj
	int objlimit;				// Limit number of obj

	mem_obj́AIuWFNg(HSPOBJINFO)i[Ă|C^
	i[Ă܂B̏ꏊAobjmax̐f[^AĊi[
	܂B܂Aobjmax̒lobjlimitɒBƁAx\܂B
	IuWFNg̐̂ɏ͂܂񂪁Ax𔭂邽߂̐
	ݒ肳Ă܂B

	short savepos[BMSCR_SAVEPOS_MAX];	// saved position

	}EX|C^̍WȂǂ̏񂪕ۑĂ܂B

	void *master_hspwnd;		// Parent hspwnd class

	BMSCR\̂ǗNXւ̃|C^i[Ă܂B
	ʏÃ|C^̓vOC͎g܂B

	short	palcolor;			// Palette color code

	pbgJ[w莞̃pbgԍۑ܂B

	short	framesx, framesy;		// Window frame xy-size

	EBhE̘gŎgpTCY(hbg)i[܂B

	int		imgbtn;			// Custom Button Flag (-1=none)
	short	btn_x1, btn_y1;			// Custom Button Image X,Y
	short	btn_x2, btn_y2;			// Custom Button Image X,Y (press)
	short	btn_x3, btn_y3;			// Custom Button Image X,Y (mouse over)

	objimage߂Őݒ肳ꂽ{^̐ݒup[^[ۑ܂B

	short	divx, divy;			// Divide value for CEL
	short	divsx, divsy;			// CEL size
	short	celofsx, celofsy;		// CEL center offset

	celdiv߂Őݒ肳ꂽ摜fނ̕ۑ܂B
	divx, divýAX,Y̕ƂȂ܂B
	divsx, divsýA1fނ̃TCYۑ܂B
	celofsx, celofsýAS_WƂȂ܂B

	COLORREF objcolor;					// object color code

	objcolor߂Őݒ肳ꂽFۑ܂B

	int		fonteff_size;				// effect size for font

	font߂Őݒ肳郁bZ[WĈۑ܂B

	int		vp_flag;					// Viewport enable flag (0=none)
	float	vp_matrix[16];				// Viewport matrix

	viewcalc߂Őݒ肳Wϊ[hyу}gNX񂪕ۑ܂B
	̗̈́AHSP3Dishł̂ݎgpAWHSP3ł͎gp܂B


rbg}bvʂւ̒ڏ

	BMSCR\̂pBitoɂ́Aʂ̃rbg}bvf[^i[Ă
	̐擪AhXi[Ă܂BgĒځAʂɃf[^
	ނƂ\łB

	ڃANZX邱ƂŁAGDIg{\
	ɂȂ܂B܂Aʂ̃hbgPʂɎRɃANZXł̂œʂ
	摜̕ϊȂǂɂɕ֗ĂB

	Aɂ͒ӂȂ΂ȂȂ_܂B

	PDʂƃAhX̑Ή㉺tɂȂĂ܂

	  Windows̃rbg}bvǗ́AȂԉ̃C珇ɏɏオ
	  \ɂȂĂ܂B̕svcȍ\̂ŁA܂܂ŉʂ̍
	  牺ɌĐiލ\ɊĂl͋ꂵނ܂B

	  Ƃ΁Aʂ̃TCY640x480(0,0)-(639,479)͈̔͂ɂ
	  Ƃ΁ApBit擪(0,479)̍W()ɂ܂B

	  AX(E)ɃAhXĂ܂A(639,479)܂Ői
	  ́A(0,478)ɂȂ܂BčĂсA(639,478)܂ŐiŁA̎
	  (0,477)ƂȂ܂B(639,0)܂ŌJԂ`Ńhbg̃f[^
	  ܂B

	  hbg̃f[^͉ʂ̐F(palmodeo)ɂĈقȂ܂B

	  tJ[[h̏ꍇ́APhbgRoCg(24bit)ŁuB,G,R,B,G,R...v
	  ̏ԂɊeF̋Px܂B܂Apbg[h̏ꍇ́A
	  PhbgPoCg(8bit)ŃpbgR[hĂ܂B

	QDʂ͈̔͊Oɂ郁ɏނƈʕیᔽoĎ~܂܂

	  rbg}bvʂ́APȂ郁̋Ԃɉ߂܂B́A͈͊O
	  Ƀf[^ނWindows̃G[ƂȂHSPʕیᔽŏI܂B
	  ʂ͈̔͂́Asx,syoŒm邱Ƃł܂BƂɔ͈͂
	  oȂ悤ɋCĂB

	  ʏ̔Cӂ̓_X,YAhX͈ȉ̎ŋ߂܂B

	  (pbg[h(256F))

	      x = XW;
	      y = YW;
	      width = (sx+3)&~3;
	      vram_adr = pBit + ( ( sy - 1 - y ) * width ) + x;

	  (tJ[[h(1670F))

	      x = XW;
	      y = YW;
	      width = ((sx*3)+3)&~3;
	      vram_adr = pBit + ( ( sy - 1 - y ) * width ) + ( x * 3 );

	RDrbg}bv́Aۂ̉ʂ̍XVKv܂

	  ́AhdcogpGDIt@NVɂ`ɂ
	  邱ƂłÃrbg}bvɕ`ĂAۂ
	  EChDʏł͉̕ωN܂B

	  ̉ʂƁAۂ̉ʏ̃EChD͕ʂłB̉
	  XV́Aۂ̉ʏ̃EChDɂ̓eRs[čXV
	  Ȃ΂Ȃ܂B

	  ύX𔽉fłȒPȕ@́AHSPredraw߂gpčĕ`
	  sȂƂłB́ASʂXVď̂ŁAЂƂƂ
	  ̉ʂIĂCredraw߂ōXV
	  IłB̕@łAGDIɔׂΏ\ɍɂȂ܂B

	  P̕@́AhwndogGetDC߂Ŏۂ̃EChDւ
	  foCXReLXg擾āAōXVƂ̂łB

	  ̕@ɂẮAuHSPT|[g[`YvŃT|[gĂ֐
	  gp邱ƂŔrIeՂɍsȂ܂B
	  ڂ́Ahsp3plugin.cpp\[Xt@CB


IuWFNgɂ

	HSP3AIuWFNg̏HSPOBJINFO\̂ƂɊǗ
	`ɕύX܂BɂA܂Ōꂽ܂łEChD
	zułȂȂA܂vOCȂǌォʂȃ[U[
	V^CṽIuWFNgǉł悤ɂȂĂ܂B
	IuWFNǵAEChDƂĔėpIɎgp邱Ƃ
	ł悤ɂȂĂ܂BƂ΁AvOCɂV`̃{^
	zuAWŃT|[gĂȂRg[zu悤
	Ƃ\ɂȂĂ܂B
	HSPOBJINFO\̂́Aȉ̂悤ȓeĂ܂B

	typedef struct HSPOBJINFO
	{
		//		Object Info (3.0)
		//
		short	owmode;		// objectmode
		short	option;		// objectoption(gpEIuWFNg0)
		void	*bm;		// objectzuĂBMSCR\̂̃|C^
		HWND	hCld;		// objecthandle
		int		owid;		// objectValue(ėp)
		int		owsize;		// object̎gpTCY(ėp)

		HSP3VARSET varset;	// objectݒ肳ϐ̏

		//		callback function
		void	(*func_notice)( struct HSPOBJINFO *, int );
		void	(*func_objprm)( struct HSPOBJINFO *, int, void * );
		void	(*func_delete)( struct HSPOBJINFO * );

	} HSPOBJINFO;

	HSPOBJINFO\̂́AvOC擾Aݒ肷邱Ƃ\łB
	etB[h̏ڍׂ́Aȉ̒ʂłB

	short	owmode;		// objectmode

	IuWFNg̃[hi[܂B
	ȉ̂ꂩlƂĊi[Ă܂B

		#define HSPOBJ_NONE 0		// 
		#define HSPOBJ_TAB_ENABLE 1	// TABtH[JXړ\
		#define HSPOBJ_TAB_DISABLE 2	// TABtH[JXړs\
		#define HSPOBJ_TAB_SKIP 3	// TABtH[JXXLbv

	void	*bm;

	zuĂBMSCR\̂̃|C^i[Ă܂B

	HWND	hCld;		// objecthandle

	zuĂIuWFNg̃EChDnhi[Ă܂B

	short	option;		// objectoption(gpEIuWFNg0)
	int		owid;		// objectValue(ėp)
	int		owsize;		// object̎gpTCY(ėp)
	HSP3VARSET varset;	// objectݒ肳ϐ̏

	IuWFNg̏[`ŔėpIɎgpłtB[hłB
	varset́AɃIuWFNg̓eƂƂɁAϐ̓eύX
	ꍇ̕ϐi[邽߂Ɏgp܂B

	void	(*func_notice)( HSPOBJINFO *, int );
	void	(*func_objprm)( HSPOBJINFO *, int, void * );
	void	(*func_delete)( HSPOBJINFO * );

	IuWFNg̏[`R[obN֐ƂĊi[܂B
	func_deletéAIuWFNgj鎞ɌĂяo֐ɂȂ܂B
	IuWFNǵAKō폜悤ɂĂB
	func_noticéAEChDbZ[W̒ʒmɌĂяo
	֐ɂȂ܂Bintp[^[ɂ́AwParam̓en܂B
	func_noticeR[obN𔭐邽߂ɂ́AHSP̃EChD
	WM_COMMANDbZ[W𑗂悤ȃRg[zuȂ
	Ȃ܂B܂AWM_COMMANDbZ[WɕtR[hƂāA
	(MESSAGE_HSPOBJ+IuWFNgID)ݒ肵ĂKv܂B
	func_objprḿAobjprm߂IuWFNgɒڒlꂽ
	sȂ֐w肵܂Bint̓p[^[^(HSPVAR_FLAG_*)
	void *́Ap[^[̃|C^܂B
	̃R[obN֐ƂƂɁAHSPOBJINFO\̂ݒ肷邱Ƃ
	Ǝ̃IuWFNgRɊgĂƂ\łB


HSPCxgɂ

	HSPCxǵAHSPŎsɔCxgʒm̂ŁA
	̃JeS[Ƃɏ擾Au邱Ƃ\
	ȂĂ܂BƂ΁At@C̓o͂ʂȃfoCXɂΉA
	picload߂̓ǂݍ݃tH[}bggȂǊ̓vOC
	Rg[ł悤ɐ݌vĂ܂B

	HSPCxǵA̃JeS[AvOC̏֐
	Cxg̃R[obN֐w肷邱Ƃ\łB
	JeS[͈ȉ̂̂pӂĂ܂B

	#define HSPEVENT_ENABLE_COMMAND 1	// PXebvs
	#define HSPEVENT_ENABLE_HSPIRQ 2	// HSPł̊荞ݔ
	#define HSPEVENT_ENABLE_GETKEY 4	// L[`FbN
	#define HSPEVENT_ENABLE_FILE 8		// t@Co͎
	#define HSPEVENT_ENABLE_MEDIA 16	// fBAo͎
	#define HSPEVENT_ENABLE_PICLOAD 32	// picloadߎs

	CxgR[obN𔭐邽߂ɂ́ACxgʂoption
	tB[hɐݒ肷Kv܂B
	ȉ́AHSPEVENT_ENABLE_GETKEYݒ肵eventfuncƂ֐
	o^ĂłB

	//	CxgR[obN𔭐Cxgʂݒ肷
	info->option = HSPEVENT_ENABLE_GETKEY;
	info->eventfunc = eventfunc;	// Cxg֐(eventfunc)̓o^

	ŁAgetkey߂stick߂Ȃǂ̃L[`FbÑCxg
	Cxg֐Ăяo邱ƂɂȂ܂B
	JeS͏dĎw肷邱Ƃ\łBAPXebvs
	Ď邽߂HSPEVENT_ENABLE_COMMANDJeS[́Aݒ肷ƂׂĂ
	ߎsɃCxg悤ɂȂ邽ߑŜ̎sxቺ܂B
	̃JeS[́AfobOړÎ߂Ɏgp悤ɂĂB

	ȉ́AHSPEVENT_ENABLE_GETKEY甭Cxg邽߂
	Cxg֐̗łB

	static int eventfunc( int event, int prm1, int prm2, void *prm3 )
	{
		//		Cxg (HSPCxgɌĂ΂܂)
		//
		switch( event ) {
		case HSPEVENT_GETKEY:
			{
			int *ival;
			ival = (int *)prm3;
			*ival = 123;
			return 1;
			}
		}
		return 0;
	}

	̗ł́Agetkey߂Ŏ擾錋ʂ123Ƃlɒu܂B
	̂悤ɃCxg֐ł́ACxg̎ʂ炻̓euA
	܂͎擾ƂA̓ĂKv܂B
	Cxg֐́Aluꍇɂ0ȊO̒lԂ悤
	ĂBCxg̓e擾A܂͏ĂȂ
	ꍇɂ0ԂĉBɂAK؂ɃCxgsȂ܂B
	܂A
	̃vOCJeS[̃Cxg擾悤ƂĂꍇ́A
	vOCo^ꂽԂɏ܂B
	0Ԃ(ĂȂ)ꍇ́AJeS[̃Cxg
	擾ĂʂȃvOCɂCxgn܂B
	0ȊOԂꂽꍇɂ́A̎_ŃCxg͏I܂Bȍ~
	vOCɏn邱Ƃ͂܂B

	vOCAHSPCxg𔭐邱Ƃ\łB

	int code_event( int event, int prm1, int prm2, void *prm3 );

	̊֐ŒڃCxgHSPɓnƂł܂B
	ɂA胉xւ̃WvATu[`WvA
	ϐւ̑ȂǂsȂƂł܂B
	̃CxǵAɃEChD̃IuWFNgȂǂ
	gpĂ܂B

	HSPCxǵAȉ̎ނ܂B
	CxgƂɓnp[^[̓eقȂ܂B

	HSPEVENT_COMMAND
		prm1 : ԃR[h^CvID
		prm2 : ԃR[hTuID
		prm3 : Ȃ

		HSPPߎs邽тɔCxgB
		ŎsȂǂ쐬邽߂ɗpĂ܂B

	HSPEVENT_HSPIRQ
		prm1 : IRQ ID#
		prm2 : iparaml
		prm3 : IRQDAT̃|C^

		HSPݔ̏CxgB

	HSPEVENT_GETKEY
		prm1 : L[R[h
		prm2 : option
		prm3 : Ԓl̃|C^

		L[̓`FbNɃtbN銄荞݂łB

	HSPEVENT_STICK
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ԓl̃|C^

		stick߃`FbNɃtbN銄荞݂łB

	HSPEVENT_FNAME
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : |C^

		t@C֘A荞݂ŎgppXo^܂B

	HSPEVENT_FREAD
		prm1 : 擪̃ItZbg
		prm2 : ǂݍ݃TCY
		prm3 : ǂݍ݃|C^

		HSPEVENT_FNAMEŎw肵t@Cɓǂݍ݂܂B

	HSPEVENT_FWRITE
		prm1 : 擪̃ItZbg
		prm2 : ݃TCY
		prm3 : f[^̃|C^

		̃f[^HSPEVENT_FNAMEŎw肵t@Cɏ݂܂B

	HSPEVENT_FEXIST
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ȃ

		HSPEVENT_FNAMEŎw肵t@C̃TCY𒲂ׂ܂B
		ʂ̓VXeϐstatɕԂ܂B

	HSPEVENT_FDELETE
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ȃ

		HSPEVENT_FNAMEŎw肵t@C폜܂B

	HSPEVENT_FMKDIR
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ȃ

		HSPEVENT_FNAMEŎw肵fBNg쐬܂B

	HSPEVENT_FCHDIR
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ȃ

		HSPEVENT_FNAMEŎw肵fBNgɈړ܂B

	HSPEVENT_FCOPY
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Rs[t@Cւ̃|C^

		HSPEVENT_FNAMEŎw肵t@CRs[܂B

	HSPEVENT_FDIRLIST1
		prm1 : dirlistIvV
		prm2 : Ȃ
		prm3 : ʂ̃|C^(char **)

		HSPEVENT_FNAMEŎw肵ChJ[hfBNg
		t@Cꗗ擾܂B

	HSPEVENT_FDIRLIST2
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ȃ

		HSPEVENT_FDIRLIST1mۂj܂B
		KAHSPEVENT_FDIRLIST1̌ɌĂяo܂B

	HSPEVENT_GETPICSIZE
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : Ԓl̃|C^

		HSPEVENT_FNAMEŎw肵摜t@C̓ǂݍݏsȂ܂B
		prm3|C^int^ŁAX,YTCY̏񂪕Ԃ܂B

	HSPEVENT_PICLOAD
		prm1 : Ȃ
		prm2 : Ȃ
		prm3 : foCXReLXg̃nh(HDC)

		HSPEVENT_GETPICSIZEɂēǂݍ܂ꂽ摜t@C
		ۂ̃foCXɕ`悵܂B



HSPCTX\̂ɂ

	HSPCTX\̂́AHSP̊{IȓɊւi[Ă܂B
	vOCctxƂOŎQƂ邱Ƃ\łB

	typedef struct HSPCTX
	{
	//	HSP Context
	//
	HSPHED *hsphed;						// HSP object file header
	unsigned short *mcs;				// current code segment ptr
	unsigned short *mem_mcs;			// code segment ptr
	char *mem_mds;						// data segment ptr
	unsigned char *mem_di;				// Debug info ptr
	int *mem_ot;						// object temp segment ptr

	IRQDAT *mem_irq;					// IRQ data ptr
	int irqmax;							// IRQ data count
	int iparam;							// IRQ Info data1
	int wparam;							// IRQ Info data2
	int lparam;							// IRQ Info data3

	PVal *mem_var;						// var storage index
	HSPEXINFO30 exinfo;					// HSP function data(3.0)
	int runmode;						// HSP execute mode
	int waitcount;						// counter for wait
	int waitbase;						// wait sleep base
	int waittick;						// next tick for await
	int lasttick;						// previous tick
	int sublev;							// subroutine level
	LOOPDAT mem_loop[HSP3_REPEAT_MAX];	// repeat loop info
	int looplev;						// repeat loop level
	HSPERROR err;						// error code
	int hspstat;						// HSP status
	int stat;							// sysvar 'stat'
	int strsize;						// sysvar 'strsize'
	char *refstr;						// RefStr Buffer
	char *fnbuffer;						// buffer for FILENAME
	void *instance;						// Instance Handle (windows)
	int intwnd_id;						// Window ID (interrupt)
	PVal *note_pval;					// MemNote pval
	APTR note_aptr;						// MemNote aptr
	PVal *notep_pval;					// MemNote pval (previous)
	APTR notep_aptr;					// MemNote aptr (previous)
	char *stmp;							// String temporary buffer

	void *prmstack;						// Current parameter stack area
	LIBDAT *mem_linfo;					// Library info
	STRUCTPRM *mem_minfo;				// Parameter info
	STRUCTDAT *mem_finfo;				// Function/Struct info
	int retval_level;					// subroutine level (return code)
	int endcode;						// End result code
	void (*msgfunc) (HSPCTX *);			// Message Callback Proc.
	void *wnd_parent;					// Parent Window Handle
	double refdval;						// sysvar 'refdval'
	char *cmdline;						// Command Line Parameters

	HSPEXINFO *exinfo2;					// HSP function data(3.1)

	} HSPCTX;

	ȉ́AetB[h̏ڍׂłB

	HSPHED *hsphed;			// HSP object file header

	HSPIuWFNgt@C(axt@C)̃wb_|C^i[܂B

	unsigned short *mcs;		// current code segment ptr
	unsigned short *mem_mcs;	// code segment ptr

	s̃R[hʒuƁAԃR[hi[Ă|C^i[܂B

	char *mem_mds;			// data segment ptr

	ef[^ۑĂ̈(data segment)|C^i[܂B

	unsigned char *mem_di;		// Debug info ptr

	fobO񂪕ۑĂ̈(Debug info)|C^i[܂B

	int *mem_ot;			// object temp segment ptr

	x񂪕ۑĂ̈(OT segment)|C^i[܂B

	IRQDAT *mem_irq;		// IRQ data ptr
	int irqmax;			// IRQ data count

	HSP̊荞ݗv(IRQDAT)̏i[܂B
	irqmaxɂ́Ai[ĂIRQDAT̐܂B

	int iparam;			// IRQ Info data1
	int wparam;			// IRQ Info data2
	int lparam;			// IRQ Info data3

	VXeϐiparam,wparam,lparam̓eێ܂B

	PVal *mem_var;			// var storage index

	O[oϐ̏񂪕ۑĂ|C^i[܂B

	HSPEXINFO30 exinfo;		// HSP function data

	HSPEXINFO30\̂i[Ă܂B
	̃f[^́AHSP3.0݊̂߂ɗpӂĂ̂ŁA
	ʏ́Aexinfo2oQƂHSPEXINFO\̂𗘗pĂB

	int runmode;			// HSP execute mode

	s[hi[܂B

	int waitcount;			// counter for wait

	wait/await߂̃JE^i[܂B

	int waitbase;			// wait sleep base

	await߂SleepԒPʂi[܂B

	int waittick;			// next tick for await
	int lasttick;			// previous tick

	await߂ł̎tickƁAOticki[܂B

	int sublev;			// subroutine level

	Tu[`̃lXgi[܂B

	LOOPDAT mem_loop[HSP3_REPEAT_MAX];	// repeat loop info
	int looplev;			// repeat loop level

	repeat`loop߂Ŏgpi[܂B

	HSPERROR err;			// error code

	G[̃G[R[hi[܂B

	int hspstat;			// HSP status

	VXeϐhspstat̓ei[܂B

	int stat;			// sysvar 'stat'

	VXeϐstat̓ei[܂B

	int strsize;			// sysvar 'strsize'

	VXeϐstrsize̓ei[܂B

	char *refstr;			// RefStr Buffer

	VXeϐrefstr̓ei[܂B

	void *instance;			// Instance Handle (windows)

	Windows̃CX^Xnhi[܂B

	char *fnbuffer;			// buffer for FILENAME

	荞ݎɎgpt@C̈ꎟLobt@̃|C^B

	void *intwnd_save;		// Window Handle (interrupt)

	WindowsbZ[WꂽEChD̃nhۑĂ܂B

	PVal *note_pval;					// MemNote pval
	APTR note_aptr;						// MemNote aptr

	m[gpbh(notesel)őIĂϐ̏ۑĂ܂B

	PVal *notep_pval;					// MemNote pval (previous)
	APTR notep_aptr;					// MemNote aptr (previous)

	notesel߂őIȌۑĂ܂B

	char *stmp;						// String temporary buffer

	֐̖߂lA߉ߎ̕ꎞޔɎgpł̈łB
	strbuf(sb`)ñCuňƂł镶|C^łB

	void *prmstack;						// Current parameter stack area

	Tu[`⃆[U[`ߓŎQƂX^bNp[^[i[܂B
	X^bNp[^[ɂ́Ȁ񂪑dɕۑĂ܂B

	LIBDAT *mem_linfo;					// Library info

	ODLLCOMȂǂ̏ǗLIBDAT\̂̃|C^i[܂B

	STRUCTPRM *mem_minfo;				// Parameter info

	ODLLCOMȂǂ̈ǗSTRUCTPRM\̂̃|C^i[܂B

	STRUCTDAT *mem_finfo;				// Function/Struct info

	W[ϐ⃆[U[`߃p[^[̏ǗSTRUCTDAT\̂
	|C^i[܂B

	int retval_level;					// subroutine level (return code)
	荞ݔ̃Tu[`lXgxi[܂B
	̒ĺAVXeǗĂ܂B

	int endcode;						// End result code

	XNvgIɃVXeɓn郌UgR[hi[܂B

	void (*msgfunc) (HSPCTX *);			// Message Callback Proc.

	EBhEbZ[W֐̃|C^i[܂B

	void *wnd_parent;					// Parent Window Handle

	HSPEBhEɓneEBhE񂪊i[܂B

	double refdval;						// sysvar 'refdval'

	VXeϐrefdval̓ei[܂B

	char *cmdline;						// Command Line Parameters

	R}hCp[^[i[܂B

	HSPEXINFO *exinfo2;					// HSP function data(3.1)

	HSPEXINFO\̂ւ̃|C^i[܂B
	̃óAHSP3.1ȍ~̂ݗp\łB


Cuɂ

	HSPCTX\̓ɂȉ̃óAXNvgŒ`Ă郉Cu
	Ă܂Bȉ̃óAODLLACOMAW[ϐȂǑ̕
	p[^[ۑĂ܂B

	LIBDAT *mem_linfo;				// Library info

	Cui[LIBDAT\̂ւ̃|C^񋟂܂B
	LIBDAT\͈̂ȉ̂悤ɒ`Ă܂B

		typedef struct LIBDAT {
			int	flag;		// initalize flag
			int	nameidx;	// function name index (DS)
						// Interface IID ( Com Object )
			void	*hlib;		// Lib handle
			int	clsid;		// CLSID (DS) ( Com Object )
		} LIBDAT;

	CúAmem_linfo[0]`mem_linfo[??]܂ł̃CfbNXŊǗ
	܂Bۂɂ́Amem_finfo烉Cu񂪎QƂ܂B

	LIBDAT\̂́A#uselibA#usecomɑΉ񂪊܂܂Ă܂B
	ꂼ̏́Aflagoɂď̎ނ܂܂B
	flag̒ĺAȉ̂ꂩɂȂ܂B

		#define LIBDAT_FLAG_NONE 0	// 
		#define LIBDAT_FLAG_DLL 1	// DLL(C|[g)
		#define LIBDAT_FLAG_DLLINIT 2	// DLL(C|[g)
		#define LIBDAT_FLAG_MODULE 3	// W[ϐ
		#define LIBDAT_FLAG_COMOBJ 4	// `ςCOMIuWFNg

	nameidxɂ́ACu(DLL)܂̓C^[tF[XIIDDSCfbNX
	i[܂BDSCfbNX́Amem_mds(data segment)̃CfbNX
	܂B( &hspctx->mem_mds[DSCfbNX] Ŏۂ̃|C^擾
	Ƃł܂B )
	hlib́AC|[gꂽDLL̃nhi[܂B
	clsid́ACOMIuWFNg`̃NXIDDSCfbNXi[܂B


	STRUCTDAT *mem_finfo;				// Function/Struct info

	t@NVȂǌʂ̏i[ĂSTRUCTDAT\̂ւ̃|C^
	񋟂܂B
	STRUCTDAT\͈̂ȉ̂悤ɒ`Ă܂B

		typedef struct STRUCTDAT {
			short	index;		// base LIBDAT index
			short	subid;		// struct index
			int	prmindex;	// STRUCTPRM index(MINFO)
			int	prmmax;		// number of STRUCTPRM
			int	nameidx;	// name index (DS)
			int	size;		// struct size (stack)
			int	otindex;	// OT index(Module) / cleanup flag(Dll)
			void	*proc;		// proc address
		} STRUCTDAT;

	STRUCTDAT́AXNvgɂĒ`ꂽP̃[U[`
	(#deffuncA#funcA#comfunc)Ɋւ񂪊܂܂Ă܂B
	index́AΉ郉CuCfbNX܂B
	(indexLIBDAT\̂֘AĂ邱ƂɂȂ܂B)
	subid́At@NV(g)̃CfbNXIDi[܂B
	(u&hspctx->mem_finfo[CfbNXID]ṽCfbNXɂȂ܂B)
	Aȃ^Cvł͈ȉ̒li[܂B

		#define STRUCTPRM_SUBID_DLL -3		// ODLL`
		#define STRUCTPRM_SUBID_DLLINIT -4	// ODLL`(*)
		#define STRUCTPRM_SUBID_OLDDLL -5	// ODLL`
		#define STRUCTPRM_SUBID_OLDDLLINIT -6	// ODLL`(*)
		#define STRUCTPRM_SUBID_COMOBJ -7	// COMĂяo

		STRUCTPRM_SUBID_OLDDLLASTRUCTPRM_SUBID_OLDDLLINIT́A
		KV[(2.x݊)ł邱ƂĂ܂B
		(*)INITtĂ̂́AC|[gς݂ł邱Ƃ
		   Ă܂B

	ۂ̃p[^[Ɋւ񂪁AprmindexŎp[^[
	i[Ă܂Bp[^[́Au&hspctx->mem_minfo[prmindex]v
	ɂĎ擾STRUCTPRM\̂ɋL^Ă܂B
	prmmax́Ap[^[̐Ă܂BƂ΁AprmmaxR
	ꍇ́AuprmindexAprmindex+1Aprmindex+2v̍vR̃p[^[
	̃t@NV񂪕ێĂ邱ƂĂ܂B܂A
	prmindexprmmax̌񂪂邱ƂɂȂ܂B
	nameidx́At@NV̖̕(܂̓t@NV)
	DSCfbNXi[܂B
	sizeɂ́Ap[^[gp郁̃TCY(oCg)i[܂B
	procɂ́AODLL`ߎɃC|[gꂽ֐AhXi[܂B
	otindex́Ã^Cvɂēe܂B

		[U[`ߎ        : OTCfbNX(x)
		ODLL`ߎ         : N[Abv߃tO(0`1)
		COMIuWFNg`ߎ : C|[gID()
		W[ϐ      : 0(Ȃ)


	STRUCTPRM *mem_minfo;				// Parameter info

	p[^[񋟂STRUCTPRM\̂ւ̃|C^񋟂܂B
	p[^[́At@NV񂩂QƂ܂B
	STRUCTPRM\͈̂ȉ̂悤ɒ`Ă܂B

		typedef struct STRUCTPRM {
			short	mptype;		// Parameter type
			short	subid;		// struct index
			int	offset;		// offset from top
		} STRUCTPRM;

	mptypéAp[^[̌^li[܂B
	p[^[̌^́Aʏȉ̒lƂȂ܂B

		#define MPTYPE_NONE 0
		#define MPTYPE_VAR 1		// ϐ
		#define MPTYPE_STRING 2		// 
		#define MPTYPE_DNUM 3		// (64bit)
		#define MPTYPE_INUM 4		// 
		#define MPTYPE_STRUCT 5		// W[ϐ^
		#define MPTYPE_LABEL 7		// x^

		#define MPTYPE_LOCALVAR -1	// [Jϐ
		#define MPTYPE_ARRAYVAR -2	// zϐ
		#define MPTYPE_SINGLEVAR -3	// ϐ̂(zȂ)
		#define MPTYPE_FLOAT -4		// 32bit
		#define MPTYPE_STRUCTTAG -5	// W[ϐ^^O
		#define MPTYPE_LOCALSTRING -6	// [J
		#define MPTYPE_MODULEVAR -7	// W[ϐ
		#define MPTYPE_PPVAL -8		// PVALւ̃|C^
		#define MPTYPE_PBMSCR -9	// BMSCRւ̃|C^
		#define MPTYPE_PVARPTR -10	// ϐւ̃|C^
		#define MPTYPE_IMODULEVAR -11	// W[ϐ

		#define MPTYPE_IOBJECTVAR -12	// COMIuWFNg^
		#define MPTYPE_LOCALWSTR -13	// [J(Unicode)
		#define MPTYPE_FLEXSPTR -14	// sptr
		#define MPTYPE_FLEXWPTR -15	// wptr
		#define MPTYPE_PTR_REFSTR -16	// refstrւ̃|C^

	subidɂ́Aʏ펩gID(p[^[CfbNX)i[
	Ă܂B
	Aȃ^Cvł͈ȉ̒li[܂B

		#define STRUCTPRM_SUBID_STACK -1 // X^bÑ[Jϐ


PVal\̂ɂ

	PVal\̂́Aϐɕۑf[^߂̏񂪊܂܂Ă܂B
	hspvar_core.hɈȉ̂悤ɒ`Ă܂B

	//	PVAL structure
	//
	typedef struct
	{
		//	Memory Data structure (2.5 compatible)
		//
		short	flag;		// type of val
		short	mode;		// mode (0=normal/1=clone/2=alloced)
		int		len[5];		// length of array 4byte align (dim)
		int		size;		// size of Val
		char	*pt;		// ptr to array

		//	Memory Data structure (3.0 compatible)
		//
		void	*master;	// Master pointer for data
		short	autoresize;	// Auto Array Expand Flag
		short	arraycnt;	// Array Set Count
		int		offset;		// Array Data Offset
		int		arraymul;	// Array Multiple Value 
	} PVal;

	擪̃tB[h́AHSP2.5ȍ~PVAL2\̂ƊSȌ݊܂B
	HSP3.0gꂽtB[hɂāA̋@\gĂ܂B
	PVal\̂Ɋւ鏈ׂ͂āAXg[WRAt@NV
	sȂ߁Aڂꂼ̃tB[h𑀍삷邱Ƃ͂܂łB
	ꂼ̃tB[hڍׂ͈ȉ̒ʂłB

	short	flag;		// type of val

	ϐ̌^i[Ă܂B
	ȉ̂ꂩA܂͊gꂽVarType̒lɂȂ܂B

		#define HSPVAR_FLAG_STR 2	// SJIS(str)
		#define HSPVAR_FLAG_DOUBLE 3	// 64bit(double)
		#define HSPVAR_FLAG_INT 4	// 32bit(int)

	short	mode;		// mode (0=normal/1=clone/2=alloced)

	ϐ쐬ꂽ[hi[Ă܂B
	ȉ̂ꂩ̒lɂȂ܂B

		#define HSPVAR_MODE_NONE -1	// 
		#define HSPVAR_MODE_MALLOC 1	// ʏmۂꂽ
		#define HSPVAR_MODE_CLONE 2	// N[ϐ

	int	len[5];		// length of array 4byte align (dim)

	z̃TCYɂĂ̏񂪊i[Ă܂B
	dim p1,p2,p3,p4ƂꍇɁAp1len[1]ɁAp2len[2]ɁA
	p3len[3]ɁAp4len[4]̒lƂȂێĂ܂B

	int		size;		// size of Val

	ϐmۂŜ̃TCYi[Ă܂B

	char	*pt;		// ptr to Val

	ۂ̕ϐ̓eLĂ郁ւ̃|C^łB
	ʏ́Azϐł΁AŎw肳ꂽAhXAI
	Ԃẑ߂ɊmۂĂ܂B
	Ȃǈꕔ̌^ł́AĂꍇ邽߁AK
	ϐێl̑́AXg[WRAt@NV
	sȂ悤ɂĂB

	short	autoresize;	// Auto Array Expand Flag
	short	arraycnt;	// Array Set Count
	int		offset;		// Array Data Offset
	int		arraymul;	// Array Multiple Value 
	void	*master;	// Master pointer for data

	ȏ̃tB[h́AXg[WRAt@NVCӂ
	p邱Ƃł܂BɁAϒzɊւ񂪊i[
	܂B


Xg[WRAt@NV(HspVarProc)ɂ


	HspVarProc\̂́AϐɊi[^CvƂ̏i[邽߂
	̂łB̍\̂ɐݒ肳ꂽcorefunc(Xg[WRAt@NV)
	ɂāAV^Ǘ邱Ƃł悤ɂȂ܂B
	hspvar_core.hɈȉ̂悤ɒ`Ă܂B

	//		command execute core function
	//
	typedef struct
	{
	//		f[^tB[h
	//
	short flag;							// ^^Cvl (eAvP[VŐݒ肳܂)
	short aftertype;					// Z̃^Cvl
	short version;						// ^^Cv^Co[W(0x100 = 1.0)
	unsigned short support;				// T|[g󋵃tO(HSPVAR_SUPPORT_*)
	short basesize;						// P̃f[^gpTCY(byte) / ϒ̎-1
	short opt;							// (gp)

	char *vartype_name;					// ^^Cvւ̃|C^
	char *user;							// [U[f[^(gp)

	//		VXeQƁE^ϊp
	//
	void *(*Cnv)( void *buffer, int flag );
	void *(*CnvCustom)( void *buffer, int flag );
	PDAT *(*GetPtr)( PVal *pval );

	void *(*ArrayObjectRead)( PVal *pval, int *mptype );// zvf̎w (Azz/ǂݏo)
	void (*ArrayObject)( PVal *pval );							// zvf̎w (Azz/ݏ)
	void (*ObjectWrite)( PVal *pval, void *data, int type );	// HSPVAR_SUPPORT_NOCONVERTw莞̑
	void (*ObjectMethod)( PVal *pval );							// ϐɑ΂郁\bh̎w

	void (*Alloc)( PVal *pval, PVal *pval2 );		// ϐmۂ
	void (*Free)( PVal *pval );						// ϐ

	int (*GetSize)( void *pdat );					// vfgp郁TCYԂ(ϒ̂)

	//		ϐobt@(oCi)̃|C^ƃTCYԂ
	//		(vfϒ(str)̏ꍇ͊YPzoCî)
	//		(vfŒ蒷(int,double)̏ꍇ͑SzoCi)
	//		(TCY̓mۃTCYԂ)
	void *(*GetBlockSize)( PVal *pval, PDAT *pdat, int *size );

	//		oCif[^pɃubNmۂ
	//		(vfϒ(str)̏ꍇɃubNTCYIɊmۂ)
	//		(Œ蒷̏ꍇ͉Ȃ)
	void (*AllocBlock)( PVal *pval, PDAT *pdat, int size );

	//		p֐(^̈vۏႳ܂)
	//
	void (*Set)( PVal *pval, PDAT *pdat, void *in );

	//		Zp֐(^̈vۏႳ܂)
	//
	void (*AddI)( PDAT *pval, void *val );
	void (*SubI)( PDAT *pval, void *val );
	void (*MulI)( PDAT *pval, void *val );
	void (*DivI)( PDAT *pval, void *val );
	void (*ModI)( PDAT *pval, void *val );

	void (*AndI)( PDAT *pval, void *val );
	void (*OrI)( PDAT *pval, void *val );
	void (*XorI)( PDAT *pval, void *val );

	void (*EqI)( PDAT *pval, void *val );
	void (*NeI)( PDAT *pval, void *val );
	void (*GtI)( PDAT *pval, void *val );
	void (*LtI)( PDAT *pval, void *val );
	void (*GtEqI)( PDAT *pval, void *val );
	void (*LtEqI)( PDAT *pval, void *val );

	void (*RrI)( PDAT *pval, void *val );
	void (*LrI)( PDAT *pval, void *val );
	} HspVarProc;


	short flag;		// ^^Cvl (eAvP[VŐݒ肳܂)

	^ƂɊUꂽIDԍݒ肳Ă܂B
	HSPVAR_FLAG_INT^^CvlĂ܂B
	^CvĺAPVal\̂flagtB[hɐݒ肳܂B

	short aftertype;	// Z̃^Cvl

	ZɃ^CvύX鉉Zqꍇ́ÃtB[h
	Z̃^CvlVXeɒʒm܂B

	short version;		// ^^Cv^Co[W(0x100 = 1.0)
	unsigned short support;	// T|[g󋵃tO(HSPVAR_SUPPORT_*)
	short basesize;		// P̃f[^gpTCY(byte) / ϒ̎-1
	short opt;		// (gp)
	char *vartype_name;	// ^^Cvւ̃|C^
	char *user;		// [U[f[^(gp)

	Xg[WRAt@NV̏Ɍ^̎ݒ肷
	Kv܂B̏ƂɁA삪肳܂B
	support́Aȉ̒畡̓eIĐݒ肵܂B

	HSPVAR_SUPPORT_STORAGE		// Œ蒷Xg[WT|[g
	HSPVAR_SUPPORT_FLEXSTORAGE	// ϒXg[WT|[g
	HSPVAR_SUPPORT_FIXEDARRAY	// zT|[g
	HSPVAR_SUPPORT_FLEXARRAY	// ϒzT|[g
	HSPVAR_SUPPORT_ARRAYOBJ		// AzzT|[g
	HSPVAR_SUPPORT_FLEXSIZE		// vfƂ̃f[^ϒ
	HSPVAR_SUPPORT_CLONE		// N[
	HSPVAR_SUPPORT_USER1		// [U[tO1
	HSPVAR_SUPPORT_USER2		// [U[tO2

	ϐɁAPVal\̂supporttB[hɓeRs[܂B
	vartype_naméA^𖼑OŎʂ邽߂̏łB
	pŐݒ肵ĂKvǍ^ƖOdȂ悤
	zKv܂B

	[U[f[^yу[U[tÓAXg[WRAt@NV
	RɎgpłtOłB


	PDAT *(*GetPtr)( PVal *pval );

	PValf[^̎Ԃ擪|C^Ԃ܂B
	(PDAT*́Aԃf[^̃|C^Ă܂B)
	zϐT|[gĂꍇ́AItZbg(PVal->offset)
	ƂɃf[^̎ԃ|C^߂Kv܂B


	void *(*ArrayObjectRead)( PVal *pval, int *mptype );// zvf̎w (Azz/ǂݏo)
	void (*ArrayObject)( PVal *pval );	// zvf̎w (Azz/ݏ)
	void (*ObjectWrite)( PVal *pval, void *data, int type );	// HSPVAR_SUPPORT_NOCONVERTw莞̑
	void (*ObjectMethod)( PVal *pval );	// ϐɑ΂郁\bh̎w

	^AzzT|[gĂ鎞(HSPVAR_SUPPORT_ARRAYOBJ)ɁA
	zŵ߂ɌĂяo܂B
	HSP3RÁAϐ̎ɂ钆ԃR[hp[XiKŁA
	֐Ăяo܂BArrayObjectAArrayObjectRead֐́AK؂ɒԃR[h
	p[XĒl߂ĂKv܂B
	ArrayObject́Aϐp[^[̕ϐw莞ɔzw肪Ă
	ɌĂяo܂BVXéAArrayObjectŔze`FbNA
	sȂꍇɂ́AObjectWriteĂяo܂B
	ObjectWrite֐́Azvfɏ]ēK؂ȒlϐɑKv܂B

	ArrayObjectRead́Aϐ̓eQƂsȂ鎞ɌĂяo܂B
	̎A߂ľ^^Cv(HSPVAR_FLAG_*)(*mptype)ɑA
	f[^̎ԃ|C^ԒlƂēn܂B
	߂ľ^^Cvǧ^łꍇ́A(*mptype)͂̂܂܂ō\܂B
	ԃR[h̃p[XɂẮA߂֐ƓlHSPEXINFO\̂ɂ
	֐𗘗pĒl擾邱Ƃ\łB
	ObjectMethod֐́Amcall߂ɂ胁\bhĂяosȂꂽɎs
	̂łBꂼ̌^ɌŗL̎s@\pӂ邱Ƃł܂B


	void *(*Cnv)( void *buffer, int flag );

	flagŃNGXgꂽ^Ǎ^ւ̕ϊsȂ߂
	֐ɂȂ܂BflagŃNGXĝ́Agݍ݌^ƂȂ
	HSPVAR_FLAG_INTAHSPVAR_FLAG_DOUBLEAHSPVAR_FLAG_STR
	ȊOHSPVAR_ERROR_TYPEMISS̃G[𔭐č\܂B
	buffeŕANGXgꂽ^f[^̃|C^ƂȂ܂B
	ϊ̂AԒlƂĖ߂Kv܂B
	buffer̓éAύXȂłB


	void *(*CnvCustom)( void *buffer, int flag );

	̌^flagŃNGXgꂽ^ւ̕ϊsȂ߂
	֐ɂȂ܂BflagŃNGXĝ́Agݍ݌^ƂȂ
	HSPVAR_FLAG_INTAHSPVAR_FLAG_DOUBLEAHSPVAR_FLAG_STR
	ȊOHSPVAR_ERROR_TYPEMISS̃G[𔭐č\܂B
	buffeŕANGXgꂽ^f[^̃|C^ƂȂ܂B
	ϊ̂AԒlƂĖ߂Kv܂B
	buffer̓éAύXȂłB
	̊֐́Agݍ݌^̒lɑ΂ĐVKɍ쐬ꂽ^̉Z
	sȂƂɌ^ϊ̂߂ɌĂяo܂B


	void (*Copy)( void *in, void *out );

	^̃TCYɍ킹in̓eoutɃRs[܂B


	void (*Alloc)( PVal *pval, PVal *pval2 );		// ϐmۂ

	pvalϐKvƂTCYmۂsȂ܂B
	pval2NULL̏ꍇ́AVKf[^ɂȂ܂B
	pval2w肳Ăꍇ́Apval2̓epčĊmۂ
	sȂƂĂ܂B̏ꍇApval2sizeAptƂ
	eRs[悤ɂĂB܂Apt̉
	sȂKv܂B

	:
		if ( pval2 != NULL ) {
			memcpy( pt, pval->pt, pval->size );
			free( pval->pt );
		}


	void (*Free)( PVal *pval );				// ϐ

	pvalmۂĂ郁܂B
	̏ꍇAHSP3RAIɌĂяosȂ܂B


	int (*GetSize)( void *pdat );	// vfgp郁TCYԂ(ϒ̂)

	pdatẽTCY(oCg)Ԃ܂B
	̊֐́APvf̃f[^TCYϒ(basesize-1)̎
	Ăяo܂Bʏ́AbasesizeƓTCY߂Ă
	B


	void *(*GetBlockSize)( PVal *pval, PDAT *pdat, int *size );

	ϐobt@(oCi)̃|C^ƃTCYԂ܂B
	vfϒ̏ꍇ͊YPz̃oCî݂ΏۂƂȂA
	vfŒ蒷(int,double)̏ꍇ͑SzoCiԂ܂B
	܂A(*size)ɃmۃTCYԂ܂B


	void (*AllocBlock)( PVal *pval, PDAT *pdat, int size );

	oCif[^pɃubNmۂ܂B
	vfϒ(str)̏ꍇɃubNTCYIɊmۂۂ
	gp܂BʏAŒ蒷̏ꍇ͉Ȃč\܂B

	void (*Set)( PVal *pval, PDAT *pdat, void *in );	// 
	void (*AddI)( PDAT *pdat, void *val );	// Zq +
	void (*SubI)( PDAT *pdat, void *val );	// Zq -
	void (*MulI)( PDAT *pdat, void *val );	// Zq *
	void (*DivI)( PDAT *pdat, void *val );	// Zq /
	void (*ModI)( PDAT *pdat, void *val );	// Zq \

	void (*AndI)( PDAT *pdat, void *val );	// Zq &
	void (*OrI)( PDAT *pdat, void *val );	// Zq |
	void (*XorI)( PDAT *pdat, void *val );	// Zq ^

	void (*EqI)( PDAT *pdat, void *val );	// Zq =
	void (*NeI)( PDAT *pdat, void *val );	// Zq !=
	void (*GtI)( PDAT *pdat, void *val );	// Zq <
	void (*LtI)( PDAT *pdat, void *val );	// Zq >
	void (*GtEqI)( PDAT *pdat, void *val );	// Zq <=
	void (*LtEqI)( PDAT *pdat, void *val );	// Zq >=

	void (*RrI)( PDAT *pdat, void *val );	// Zq >>
	void (*LrI)( PDAT *pdat, void *val );	// Zq <<

	ꂼ̉ZqɑΉZp֐łB
	PDATœnf[^́AƂ̌^̈vۏႳ܂B
	Zp֐́Apdatval̉ZʂpdatɕԂ܂B


HSPwb_ɂ

	HSPHED\̂́AHSPt@CIuWFNgɊ܂܂Ă܂Ƃ߂
	̂ŁAHSPCTX\̂hsphedQƂ邱Ƃł܂B
	HSPHED\̂́Ahsp3struct.hɈȉ̂悤ɒ`Ă܂B

	typedef struct HSPHED
	{
	//		HSP3.0 header structure
	//

	char	h1;					// magic code1
	char	h2;					// magic code2
	char	h3;					// magic code3
	char	h4;					// magic code4
	int		version;			// version number info
	int		max_val;			// max count of VAL Object
	int		allsize;			// total file size

	int		pt_cs;				// ptr to Code Segment
	int		max_cs;				// size of CS
	int		pt_ds;				// ptr to Data Segment
	int		max_ds;				// size of DS

	int		pt_ot;				// ptr to Object Temp
	int		max_ot;				// size of OT
	int		pt_dinfo;			// ptr to Debug Info
	int		max_dinfo;			// size of DI

	int		pt_linfo;			// ptr to LibInfo(2.3)
	int		max_linfo;			// size of LibInfo(2.3)
	int		pt_finfo;			// ptr to FuncInfo(2.3)
	int		max_finfo;			// size of FuncInfo(2.3)

	int		pt_minfo;			// ptr to ModInfo(2.5)
	int		max_minfo;			// size of ModInfo(2.5)
	int		pt_finfo2;			// ptr to FuncInfo2(2.5)
	int		max_finfo2;			// size of FuncInfo2(2.5)

	int		pt_hpidat;			// ptr to HPIDAT(3.0)
	int		max_hpi;			// size of HPIDAT(3.0)
	int		bootoption;			// bootup options
	int		runtime;			// ptr to runtime name

	} HSPHED;


zϐ̎擾Ɛݒ

	ϐ擾code_getvaɂAzvfɎ擾܂B
	{Iɕϐ́APVal|C^ƂāAzvf́AAPTR̒lƂ
	擾܂B
	APTR̒l0̏ꍇ́Azvfw肳ĂȂƂĂ܂B
	APTR͔zvf̃CfbNXĂ܂B
	́AׂĂ̎1ɒł̍őCfbNXlɂȂ܂B
	1zł΁AAPTR0,1,2ĉ܂ܔzvfƓ
	lĖ肠܂B

	code_getvaŎ擾APTR͔͈̓`FbNĂ̂ŁA
	ʏ̎gpł̓vOCŔ͈̓`FbNsȂKv͂܂B

	AvOCŔCӂɔzvfݒ肵ꍇɂ́A
	HspFunc_array֐gp܂B

	̂悤Ȍ`ŗvfwsȂƂ\łB
	(APTR̒l=pval->offset̒lł)

		HspVarCoreReset( pval );// z|C^Zbg
		HspFunc_array( pval, 0 );// 1
		HspFunc_array( pval, 0 );// 2
		HspFunc_array( pval, 0 );// 3
		HspFunc_array( pval, 0 );// 4

	܂Az̊gHspFunc_redim֐ōsȂƂ\łB

		void (*HspFunc_redim)( PVal *pval, int lenid, int len );

	̊֐ł́Aw肵ϐ̔zg܂B
	pvalϐ́Aw肵lenid(1`4)ɑ΂len̑傫Ɋg܂B


code_getprm̒ӓ_

	^̕sȃp[^[擾邽߂code_getprm֐ł́A
	ꎞIȃp[^[ۊǂsȂmpvalϐčsȂ܂B
	mpvaĺAXNvgŎw肳ĂϐPVal|C^
	(code_getvaŎ擾PVal|C^)Ƃ͈قȂ̂ŒӂĂB
	܂Ampval|C^̓VXeǗĂ邽߁Al̏CA
	^̕ύXȂǁA\̂̓eύX鏈͔ĉB


BMSCR\̂logfontoɂ

	BMSCR\̂logfontoAHSP3.6ύXɂȂĂ܂B

	LOGFONT	*logfont;			// logical font (HSP3.6ȍ~)
	LOGFONT	logfont;			// logical font (HSP3.6ȑO)

	logfont͑Iꂽ_tHg̍\̂i[܂B
	HSP3.6ȑOLOGFONT\̂`Ă܂AHSP3.6ȍ~̓|C^ɕύXĂ܂B
	vOCł̍ڂ𑀍삷邱Ƃ͂قƂǂȂƎv܂AYꍇ͒ӂĂB
	HSP3.6ȍ~łApfBÖĂ邽ߏ]̍\̂TCŶɕύX͂Ȃ̂ŁA
	̕ύXɂÃoe󂯂邱Ƃ͂܂B


֐쐬ł̒ӓ_

	ADLL̊֐Œ[v邱ƂƁAWindowsŜ̃^XN
	DĂ܂̂ŁAȂׂA悤ɐSĂB
	̂́AHSP̃^XNɊւ钍ӓ_ƓlłB
	HSP̂́AVOXbhœ삵Ă܂AvOC
	}`Xbhœ삳邱Ƃ\łB̏ꍇłAHSP
	lsɏ悤ȂƂ̂Ȃ悤ɒӂĂB


Ō

	̃hLgɊւ邨₢킹AzAӌȂǂ͈ȉ̃[
	AhX܂ł肢v܂B(₢킹̕ԐMɂẮAԂ
	邱Ƃ܂̂ŁAB)
	^p̃CZXɂẮAreadme.txtQƂĂB

	Homepage: http://www.onionsoft.net/
        e-mail  : onitama@onionsoft.net

------------------------------------------------------------------------------
                                                     HSPDLL.TXT / end of file 
------------------------------------------------------------------------------
