小ワザ/ポインタを使ってのあれこれ

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
-
|
-
|
-
|
-
|
|
-
|
!
|
!
 
 
 
 
 
 

//(mod_pval.hsp)==============================================================
#ifndef __MOD_PVAL__
#define __MOD_PVAL__
//(module part start)=========================================================
#module mod_pval
#define prmstack    207
 
#define global ctype pvalptr(%1) pvalptr_(%1, 0)
    ;	指定した変数のPVALポインタ値を取得
#define global ctype getaptr(%1) pvalptr_(%1, 1)
    ;	指定した(配列)変数のAPTR値を取得
 
#defcfunc pvalptr_ var _p1, int _p2
    mref HSPCTX, 68
    dupptr vptr, HSPCTX.prmstack, 8, 4
    return vptr(_p2)
 
/*
#defcfunc pvalptr_b_ var _p1, int _p2
	;	別の方法での取得
	dim old, 5
	dim vptr, 2
	old(0)=ginfo(3)
	gsel 0, 0
	mref BMSCR, 67
	old(1)=ginfo(22), ginfo(23), BMSCR(29), BMSCR(30)
	objsize 0, 0
	input _p1
	oidI=stat
	vptr=objinfo(oidI, 6), objinfo(oidI, 7);	PVAL構造体へのポインタ
	clrobj oidI
	pos old(1), old(2)
	objsize old(3), old(4)
	gsel old(0), 0
	return vptr(_p2)
*/
 
#deffunc getpval array _p1, var _p2
    ;	_p2 で指定した変数に対する PVAL構造体の内容を _p1 で指定した変数にコピーする
    ;	_p1 で指定した変数は整数型配列変数に変換されます。
    ;	内容のコピーであって、後から _p1 で指定した変数の内容を変更しても
    ;	元の PVAL構造体の内容は変化しません
    dim _p1, 12
    dupptr PVAL, pvalptr(_p2), 48, 4
    memcpy _p1, PVAL, 48
    return
 
#defcfunc varclone var _p1
    ;	_p1 で指定した変数の現在の状態がクローン変数なのか実体のある変数なのかを調べます
    ;	クローン変数なら 1、実体があるなら 0 を返します
    dupptr tmpPVAL, pvalptr(_p1), 48, 4
    if (tmpPVAL(0) & 0xFFFF0000)=0x00020000 : return 1
    if (tmpPVAL(0) & 0xFFFF0000)=0x00010000 : return 0
    return -1
 
#defcfunc bufsize var _p1
    ;	_p1 で指定した変数用に現在確保されているバッファサイズを取得
    ;	配列変数の場合は引数に指定した配列要素一つが対象です。
    ;	配列変数全体のバッファサイズを返すものではありません。
    dupptr tmpPVAL, pvalptr(_p1), 48, 4
    if (tmpPVAL(0) & 0x0000FFFF)=0x00000004 {
        return 4
    } else : if (tmpPVAL(0) & 0x0000FFFF)=0x00000003 {
        return 8
    } else : if (tmpPVAL(0) & 0x0000FFFF)=0x00000002 {
        tmpAPTR=getaptr(_p1)
        if tmpAPTR {
            dupptr tmpPD, tmpPVAL(8)+tmpAPTR*4, 4, 4
            dupptr tmpSTRINF, tmpPD-24, 24, 4
        } else {
            dupptr tmpSTRINF, tmpPVAL(7)-24, 24, 4
        }
        return tmpSTRINF(2)
    }
    return 0
 
#global
//(module part end)===========================================================
#endif;	#ifndef __MOD_PVAL__
//(EOF)=======================================================================

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37

//	サンプル
//	PVAL構造体からの情報取得
//	標準命令で取得できるものと同じ情報を取得
#include "mod_pval.hsp"
 
    mes "整数型の場合 : dim test, 2, 5, 7, 4"
    dim test, 2, 5, 7, 4
    getpval pvaltest, test
    mes "変数の型 (vartype 関数と同じ)
	mes ""+(pvaltest(0) & 0xFF)+"    ("+vartype(test)+")"
	mes "各次元ごとの配列の要素数 (length 系関数と同じ)
    mes "一次元 : "+pvaltest(2)+"    ("+length(test)+")"
    mes "二次元 : "+pvaltest(3)+"    ("+length2(test)+")"
    mes "三次元 : "+pvaltest(4)+"    ("+length3(test)+")"
    mes "四次元 : "+pvaltest(5)+"    ("+length4(test)+")"
    mes "実際の内容へのポインタ (varptr 関数と同じ)
	mes strf("%08X", pvaltest(7))+strf("    (%08X)", varptr(test))
	mes "実際の内容へのポインタ(配列要素) (varptr 関数と同じ)
    mes strf("%08X", pvaltest(7)+4*getaptr(test(1, 3, 6, 0)))+strf("    (%08X)", varptr(test(1, 3, 6, 0)))
 
 
    mes
    mes "実数型の場合 : ddim test, 7, 3, 4, 2"
    ddim test, 7, 3, 4, 2
    getpval pvaltest, test
    mes "変数の型 (vartype 関数と同じ)
	mes ""+(pvaltest(0) & 0xFF)+"    ("+vartype(test)+")"
	mes "各次元ごとの配列の要素数 (length 系関数と同じ)
    mes "一次元 : "+pvaltest(2)+"    ("+length(test)+")"
    mes "二次元 : "+pvaltest(3)+"    ("+length2(test)+")"
    mes "三次元 : "+pvaltest(4)+"    ("+length3(test)+")"
    mes "四次元 : "+pvaltest(5)+"    ("+length4(test)+")"
    mes "実際の内容へのポインタ (varptr 関数と同じ)
	mes strf("%08X", pvaltest(7))+strf("    (%08X)", varptr(test))
	mes "実際の内容へのポインタ(配列要素) (varptr 関数と同じ)
    mes strf("%08X", pvaltest(7)+8*getaptr(test(6, 2, 2, 1)))+strf("    (%08X)", varptr(test(6, 2, 2, 1)))
   

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31

//	サンプル
//	PVAL構造体からの情報取得
//	標準命令では取得できない情報を取得(モジュール拡張関数を使用)
#include "mod_pval.hsp"
 
    mes "クローン変数かどうか(varclone)    =1:クローン変数"
    a=100                        : mes strf("a=%-10d", a)+"  :  varclone(a)="+varclone(a)
    b=99.99                        : mes strf("b=%-10f", b)+"  :  varclone(b)="+varclone(b)
    c="abcd"                    : mes "c=\""+c+"\"      :  varclone(c)="+varclone(c)
    dup d, a                    : mes strf("d=%-10d", d)+"  :  varclone(d)="+varclone(d)
    dupptr e, varptr(b), 8, 3    : mes strf("e=%-10f", e)+"  :  varclone(e)="+varclone(e)
    dupptr f, varptr(c), 4, 4    : mes strf("f=%-10d", f)+"  :  varclone(f)="+varclone(f)
 
    mes
    mes "変数の現在のバッファサイズを取得(bufsize)"
    i=100   : mes strf("i=%-11d", i)+"  :  bufsize(i)="+bufsize(i)
    d=99.99 : mes strf("d=%-11f", d)+"  :  bufsize(d)="+bufsize(d)
    sdim st0, 64  : mes "sdim st0, 64 "+"  :  bufsize(st0)="+bufsize(st0)
    sdim st1, 200 : mes "sdim st1, 200"+"  :  bufsize(st1)="+bufsize(st1)
    sdim st2, 777 : mes "sdim st2, 777"+"  :  bufsize(st2)="+bufsize(st2)
 
    mes
    sdim st, 64, 3 : mes "sdim st, 64, 3"
    st="0123"
    repeat 70 : st(1)=st(1)+cnt\10 : loop
    repeat 500 : st(2)=st(2)+""+rnd(10) : loop
    repeat 3
        mes "st("+cnt+")=\""+st(cnt)+"\""
        mes "strlen(st("+cnt+"))="+strlen(st(cnt))+"  :  bufsize(st("+cnt+"))="+bufsize(st(cnt))
        mes
    loop

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42

#module
#define prmstack    207
 
#deffunc test int _i, var _v, array _a, str _s, double _d
    mref ctx, 68
 
    ;	int		 : 4 byte , 値そのもの
    dupptr i, ctx.prmstack, 4, 4
    mes i
 
    ;	var		 : 8 byte , PVALポインタ, APTR値
    dupptr ptr, ctx.prmstack+4, 8, 4
    dupptr pval, ptr(0), 48, 4;	PVAL構造体
    mes strf("型 : %1d", pval(0) & 0xFF)+strf("    配列一次元要素 : %2d", pval(2))
 
    ;	array	 : 8 byte , PVALポインタ, APTR値
    dupptr ptr, ctx.prmstack+12, 8, 4
    dupptr pval, ptr(0), 48, 4;	PVAL構造体
    mes strf("型 : %1d", pval(0) & 0xFF)+strf("    配列一次元要素 : %2d", pval(2))
 
    ;	str		 : 4 byte , 文字列へのポインタ
    dupptr ptr, ctx.prmstack+20, 4, 4
    dupptr s, ptr, 64, 2
    mes s
 
    ;	double	 : 8 byte , 値そのもの
    dupptr d, ctx.prmstack+24, 8, 3
    mes d
 
    return
#global
 
    v=65535.32768
    a=127, 255
    test 100, v, a(0), "ABC", 99.9999
    mes
 
    v="string"
    a=0, 1, 2, 3, 4
    c="01234"
    test -10000, v, a(1), c, 100.001
   

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31

#include "mod_pval.hsp"
#module
#deffunc disp array p1
    mes "flag    = "+ wpeek(p1(0), 0)
    mes "exflag  = "+ wpeek(p1(0), 2)
    mes "myblock = "+ p1(1)
    mes "size    = "+ p1(2)
    mes "ptr     = "+ strf("0x%08X", p1(3))
    mes "extptr  = "+ strf("0x%08X", p1(4))
    mes "opt     = "+ strf("0x%08X", p1(5))
    dupptr data, p1(3), p1(2), 2
    mes "data    = "+ data
    return
#global
 
s  = "abc"
ss = "naznyark", "kz3"
 
dupptr pval, pvalptr(s), 48
dupptr strbuf, pval(7) - 24, 88
disp strbuf
 
dupptr pval, pvalptr(ss), 48
dupptr master, pval(8), pval(6) : master(0) = pval(7)
repeat pval(6) / 4
    dupptr strbuf, master(cnt) - 24, 88
    mes "----"
    disp strbuf
loop
 
stop