home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 3 / FREEWARE.BIN / towns_os / whisper / source / func.c < prev    next >
Text File  |  1980-01-02  |  21KB  |  1,045 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <ctype.h>
  5. #include    <time.h>
  6. #include    <mos.h>
  7. #include    "event.h"
  8. #include    "graphic.h"
  9. #include    "defs.h"
  10. #include    "coldef.h"
  11.  
  12. #define FUNC_MAX        (32*1024)
  13.  
  14. void    CHK_snd(void);
  15. void    CHK_eup(void);
  16. int    PLAY_snd();
  17. int    PLAY_eup();
  18. int    END_eup();
  19. int    DSP_push_tiff();
  20. int    DSP_pop_tiff();
  21. void    DSP_super(char *str);
  22. void    DSP_pause(int x,int y,int cl,int bk,char *str);
  23. int    PLT_set();
  24. char    *WIN_file_chk();
  25. void    WIN_putc(int no,int ch);
  26. void    WIN_flush();
  27. int    WIN_type(int no,int ch);
  28. int    WIN_write_file(int no,int ch,char *file,int sw);
  29. int    WIN_secret_chk(int no,int ch);
  30. int    WIN_write_chk(int no,int ch);
  31. int    WIN_read_file(int no,int ch,char *file,int sw);
  32. void    WIN_upload(int no);
  33. char    *WIN_get_line(int no,int ch);
  34. void    CHILD_set(int no,int ch);
  35. int    MAC_init(char *ag[]);
  36. void    MEMO_insrt(int no,int ch);
  37. char    *MEMO_get_buf(void);
  38. void    MEMO_set_word(char *str);
  39. void    MEMO_chk(void);
  40. int    RSB_chk();
  41. int    RSB_getc();
  42. void    RSB_putc(int ch);
  43. void    RSB_init(int port);
  44. void    RSB_reopen(int md,int bps);
  45. void    RSB_get_para(int *pt,int *md,int *bp);
  46. void    RSB_end();
  47. int    keyword(char *file,int sw);
  48. char    *copy_file_name(char *file);
  49. int    copy(char *file,char *new);
  50. int    merge(char *org,char *file);
  51. int    type(char *file);
  52. int    COMP_lzss(char *file);
  53. int    XMODEM_upload(char *file);
  54. int    XMODEM_download(char *file);
  55. int    FILE_upload(char *file);
  56. int    CD_play();
  57. int    CD_play_no();
  58. int    CD_next();
  59. int    CD_back();
  60. int    CD_stop();
  61. int    CD_vol_up();
  62. int    CD_vol_down();
  63. int    CD_vol_set();
  64. int    CD_menu();
  65. void    DSP_anime();
  66. int    CMDS_init();
  67. int    patmatch(char *file,char *wild);
  68. int    TALK_str();
  69. int    TALK_new();
  70. int    SND_make();
  71. int    MSG_echo(char *argv[]);
  72. int    MSG_input(char *argv[]);
  73. int    MSG_yes(char *argv[]);
  74. int    MSG_yesno(char *argv[]);
  75. int    MSG_color(char *argv[]);
  76. int    MSG_bakcol(char *argv[]);
  77. int    MSG_lincol(char *argv[]);
  78. int    MSG_open_wind(void);
  79. int    TAB_set(void);
  80. int    MSG_ext_cfg(char *argv[]);
  81. int    MSG_menu_tate(char *argv[]);
  82. int    MSG_menu_state(char *argv[]);
  83. int    MSG_menu_syoko(char *argv[]);
  84. int    MSG_echo(char *argv[]);
  85. void    tsleep(int sec);
  86. void    macvalset(char *mac,int val);
  87. int    macval(char *mac);
  88. void    macset(char *mac,char *str);
  89. char    *macget(char *mac);
  90. int    MSG_close_wind(void);
  91. void    WIN_resize(void);
  92. void    DSP_one_pal(int no,int r,int g,int b);
  93. int    WIN_down_start();
  94. void    RSB_mode_set();
  95. void    RSB_break_out(void);
  96. char    *get_word(char *buf,char *str);
  97. char    *get_string(char *tmp,char *str);
  98. char    *cutpara(char *arg,char *str);
  99. char    *cutcmds(char *str);
  100. int     cmp_func(char *str);
  101. char    *prcget(char *prc);
  102. int    secret_chk(char *file);
  103. int    chdrv(int no);
  104. int    mkdir(char *name);
  105. int    rmdir(char *name);
  106. int    chdir(char *name);
  107. int    getdir(char *name);
  108. int    mem_file(char *file);
  109. void    unmem_file(char *file);
  110. void    TANGO_set(void);
  111. int    KEY_func_exec(char *func);
  112. int    MSG_system(char *argv[]);
  113. int    MSG_command(void);
  114.  
  115. extern int    TERM;
  116. extern int    msg_tab;
  117. extern int    errno;
  118. extern int    top_event;
  119. extern char     *func_ptr;
  120. extern char    func_buf[];
  121.  
  122. int    MSG_sleep(char *argv[])
  123. {
  124.     int     n;
  125.  
  126.     if ( (n = atoi(*argv)) == 0 )
  127.     n = 3;
  128.     tsleep(n);
  129.     return n;
  130. }
  131.  
  132. int    MSG_wait(char *argv[])
  133. {
  134.     int     ch,n,sw,x,y;
  135.     clock_t t;
  136.  
  137.     DSP_mos(2);
  138.     MOS_disp(TRUE);
  139.  
  140.     if ( (n = atoi(*argv)) == 0 )
  141.     n = 3;
  142.     t = clock() + CLK_TCK * n;
  143.     do {
  144.         while ( RSB_chk() > 0 ) {
  145.         ch = RSB_getc();
  146.         WIN_putc(TERM,ch);
  147.     }
  148.     WIN_flush(TERM);
  149.     MOS_rdpos(&sw,&x,&y);
  150.     CHK_snd();
  151.     CHK_eup();
  152.     } while ( sw == 0 && t > clock() );
  153.  
  154.     MOS_disp(FALSE);
  155.     DSP_mos(0);
  156.  
  157.     return (sw != 0 ? ERR:FALSE);
  158. }
  159.  
  160. int    KEY_lock(char *argv[])
  161. {
  162.     int    cd=ERR;
  163.  
  164.     while ( *argv != NULL ) {
  165.         if ( (cd = keyword(*(argv++),FALSE)) != 0 )
  166.         break;
  167.     }
  168.     return cd;
  169. }
  170.  
  171. int    KEY_unlock(char *argv[])
  172. {
  173.     int    cd=ERR;
  174.  
  175.     while ( *argv != NULL ) {
  176.         if ( (cd = keyword(*(argv++),TRUE)) != 0 )
  177.         break;
  178.     }
  179.     return cd;
  180. }
  181.  
  182. int    FIL_unlink(char *argv[])
  183. {
  184.     int     cd;
  185.  
  186.     while ( *argv != NULL ) {
  187.         if ( (cd = remove(*(argv++))) != 0 )
  188.         break;
  189.     }
  190.     return cd;
  191. }
  192.  
  193. int    FIL_complzss(char *argv[])
  194. {
  195.     int     cd;
  196.  
  197.     while ( *argv != NULL ) {
  198.         if ( (cd = COMP_lzss(*(argv++))) != 0 )
  199.         break;
  200.     }
  201.     return cd;
  202. }
  203.  
  204. int    FIL_rename(char *argv[])
  205. {
  206.     return rename(argv[0],argv[1]);
  207. }
  208.  
  209. int    FIL_copy(char *argv[])
  210. {
  211.     return copy(argv[0],argv[1]);
  212. }
  213.  
  214. int    FIL_copy_name(char *argv[])
  215. {
  216.     macset(argv[0],copy_file_name(argv[1]));
  217.     return FALSE;
  218. }
  219.  
  220. int    FIL_merge(char *argv[])
  221. {
  222.     return merge(argv[0],argv[1]);
  223. }
  224.  
  225. int    FIL_type(char *argv[])
  226. {
  227.     return type(*argv);
  228. }
  229.  
  230. int    FIL_load(char *argv[])
  231. {
  232.     return WIN_read_file(atoi(argv[0]),atoi(argv[1]),
  233.         argv[2],atoi(argv[3]));
  234. }
  235.  
  236. int    MSG_snd(char *argv[])
  237. {
  238.     while ( *argv != NULL )
  239.     PLAY_snd(*(argv++));
  240.     return FALSE;
  241. }
  242.  
  243. int    MSG_eup(char *argv[])
  244. {
  245.     while ( *argv != NULL )
  246.     PLAY_eup(*(argv++));
  247.     return FALSE;
  248. }
  249.  
  250. int    MSG_tiff(char *argv[])
  251. {
  252.     while ( *argv != NULL )
  253.     DSP_push_tiff(*(argv++));
  254.     return FALSE;
  255. }
  256. int    MSG_get_time(char *argv[])
  257. {
  258.     clock_t t;
  259.  
  260.     t = clock() / CLK_TCK;
  261.     macvalset(argv[0],t);
  262.     return t;
  263. }
  264. int    MSG_add(char *argv[])
  265. {
  266.     int     n;
  267.  
  268.     n = macval(argv[0]);
  269.     n += atoi(argv[1]);
  270.     macvalset(argv[0],n);
  271.     return n;
  272. }
  273. int    MSG_sub(char *argv[])
  274. {
  275.     int     n;
  276.  
  277.     n = macval(argv[0]);
  278.     n -= atoi(argv[1]);
  279.     macvalset(argv[0],n);
  280.     return n;
  281. }
  282. int    TERM_getc(char *argv[])
  283. {
  284.     int     len,ch;
  285.     char    tmp[2];
  286.  
  287.     len = RSB_chk();
  288.     if ( len > 0 ) {
  289.     ch = RSB_getc();
  290.     tmp[0] = ch;
  291.     tmp[1] = '\0';
  292.     } else
  293.     tmp[0] = '\0';
  294.  
  295.     macset(argv[0],tmp);
  296.  
  297.     return tmp[0];
  298. }
  299. int    TERM_gets(char *argv[])
  300. {
  301.     int     n,ch,len;
  302.     char    tmp[82];
  303.  
  304.     for ( n = 0 ; n < 80 ; ) {
  305.         len = RSB_chk();
  306.     while ( len-- > 0 && n < 80 ) {
  307.         ch = RSB_getc();
  308.         if ( ch == 0x0A ) {
  309.         break;
  310.         } else if ( ch != '\0' && ch != 0x0D )
  311.         tmp[n++] = ch;
  312.     }
  313.     }
  314.     tmp[n] = '\0';
  315.     macset(argv[0],tmp);
  316.     return n;
  317. }
  318. int    TERM_putc(char *argv[])
  319. {
  320.     RSB_putc(*argv[0]);
  321.     return *argv[0];
  322. }
  323. int    TERM_puts(char *argv[])
  324. {
  325.     char    *p;
  326.  
  327.     p = argv[0];
  328.     while ( *p != '\0' ) {
  329.     if ( *p != '\n' )
  330.         RSB_putc(*p);
  331.     p++;
  332.     }
  333.     return FALSE;
  334. }
  335. int    MSG_wind_putc(char *argv[])
  336. {
  337.     int     n;
  338.  
  339.     n = atoi(argv[0]);
  340.     WIN_putc(n,*argv[1]);
  341.     return n;
  342. }
  343. int    MSG_wind_puts(char *argv[])
  344. {
  345.     int     n;
  346.     char    *p;
  347.  
  348.     n = atoi(argv[0]);
  349.     p = argv[1];
  350.     while ( *p != '\0' )
  351.     WIN_putc(n,*(p++));
  352.     return n;
  353. }
  354. int    MSG_wind_flush(void)
  355. {
  356.     MSG_close_wind();
  357.     WIN_resize();
  358.     MOS_disp(FALSE);
  359.     return FALSE;
  360. }
  361. int    MSG_switch(char *argv[])
  362. {
  363.     int     i,fg,ch,sw,x,y;
  364.     clock_t t,l;
  365.     short   al[20];
  366.  
  367.     DSP_mos(2);
  368.     MOS_disp(TRUE);
  369.  
  370.     t = clock() + atoi(argv[0]) * CLK_TCK;
  371.     for ( i = 1 ; argv[i] != NULL ; i++ )
  372.     al[i] = 0;
  373.  
  374.     fg = ERR;
  375.     do {
  376.         while ( RSB_chk() > 0 ) {
  377.         ch = RSB_getc();
  378.         WIN_putc(TERM,ch);
  379.         for ( i = 1 ; argv[i] != NULL ; i++ ) {
  380.         if ( ch == argv[i][al[i]] ) {
  381.             al[i]++;
  382.             if ( argv[i][al[i]] == '\0' ) {
  383.             fg = (i-1);
  384.             goto ENDOF;
  385.             }
  386.         } else
  387.             al[i] = 0;
  388.         }
  389.     }
  390.     WIN_flush(TERM);
  391.     l = clock();
  392.     MOS_rdpos(&sw,&x,&y);
  393.     } while ( l < t && sw == 0 );
  394.  
  395. ENDOF:
  396.     MOS_disp(FALSE);
  397.     DSP_mos(0);
  398.     return fg;
  399. }
  400.  
  401. int    MSG_mos(char *argv[])
  402. {
  403.     int     sw,x,y;
  404.  
  405.     MOS_rdpos(&sw,&x,&y);
  406.     if ( argv[0] != NULL ) {
  407.     macvalset(argv[0],sw);
  408.     if ( argv[1] != NULL ) {
  409.         macvalset(argv[1],x);
  410.         if ( argv[2] != NULL )
  411.         macvalset(argv[2],y);
  412.     }
  413.     }
  414.     return sw;
  415. }
  416. int    TERM_open(char *argv[])
  417. {
  418.     int md;
  419.  
  420.     if ( argv[0] != NULL )
  421.     RSB_init(atoi(argv[0]));
  422.     else
  423.     RSB_init(0);
  424.  
  425.     md =  macval("_BIT") |
  426.      (macval("_PARISW") << 1) |
  427.      (macval("_PARITY") << 2) |
  428.      (macval("_STOPBIT") << 3) |
  429.      (macval("_XONXOFF") << 4);
  430.     RSB_reopen(md,macval("_BPS"));
  431.  
  432.     return FALSE;
  433. }
  434. int    TERM_para(void)
  435. {
  436.     int pt,md,bp;
  437.  
  438.     RSB_get_para(&pt,&md,&bp);
  439.     macvalset("_PORT",pt);
  440.     macvalset("_BIT",md & 1);
  441.     macvalset("_PARISW",(md >> 1) & 1);
  442.     macvalset("_PARITY",(md >> 2) & 1);
  443.     macvalset("_STOPBIT",(md >> 3) & 1);
  444.     macvalset("_XONXOFF",(md >> 4) & 1);
  445.     macvalset("_BPS",bp);
  446.     return pt;
  447. }
  448. int    TERM_close()
  449. {
  450.     RSB_end();
  451.     return FALSE;
  452. }
  453. int    MSG_wind_type(char *argv[])
  454. {
  455.     return WIN_type(atoi(argv[0]),atoi(argv[1]));
  456. }
  457. int    MSG_wind_save(char *argv[])
  458. {
  459.     return WIN_write_file(atoi(argv[0]),atoi(argv[1]),
  460.               argv[2],atoi(argv[3]));
  461. }
  462. int    MSG_wind_file(char *argv[])
  463. {
  464.     char    *p;
  465.  
  466.     p = WIN_file_chk(atoi(argv[0]),atoi(argv[1]));
  467.     macset(argv[2],p == NULL ? "":p);
  468.  
  469.     return ( p == NULL ? ERR:FALSE);
  470. }
  471. int    MSG_wind_secret(char *argv[])
  472. {
  473.     int     n;
  474.  
  475.     n = WIN_secret_chk(atoi(argv[0]),atoi(argv[1]));
  476.     macvalset(argv[2],n);
  477.     return n;
  478. }
  479. int    MSG_wind_wrt_chk(char *argv[])
  480. {
  481.     int     n;
  482.  
  483.     n = WIN_write_chk(atoi(argv[0]),atoi(argv[1]));
  484.     macvalset(argv[2],n);
  485.     return n;
  486. }
  487. int    date2day(int year,int month,int date)
  488. {
  489.     int     days;
  490.  
  491.     if (month < 3) {
  492.         --year;
  493.         month += 13;
  494.     } else
  495.     ++month;
  496.  
  497.     days = (year * 0x16d4l) >> 4;        /* 16d.4 -> 365.25 */
  498.     days += (month * 0x1e99al) >> 12;        /* 1e.99a -> 30.6001 */
  499.     days += date;
  500.     return(days);
  501. }
  502. int    MSG_date_day(char *argv[])
  503. {
  504.     int     y,m,d;
  505.  
  506.     sscanf(argv[0],"%d/%d/%d",&y,&m,&d);
  507.     return date2day(y,m,d);
  508. }
  509. int    MSG_super(char *argv[])
  510. {
  511.     int     i,n;
  512.     char    *p;
  513.     char    tmp[82];
  514.  
  515.     if ( (p = *(argv++)) != NULL ) {
  516.     i = 0;
  517.     while ( *p != '\0' ) {
  518.         if ( *p == '\t' ) {
  519.             n = msg_tab - (i % msg_tab);
  520.         while ( n-- > 0 )
  521.             tmp[i++] = ' ';
  522.         p++;
  523.         } else
  524.         tmp[i++] = *(p++);
  525.     }
  526.     tmp[i] = '\0';
  527.     p = tmp;
  528.     }
  529.     DSP_super(p);
  530.     return FALSE;
  531. }
  532. int    FIL_access(char *argv[])
  533. {
  534.     FILE    *fp;
  535.  
  536.     if ( (fp = fopen(*argv,"r")) != NULL )
  537.     fclose(fp);
  538.  
  539.     return (fp == NULL ? FALSE:TRUE);
  540. }
  541. int    FIL_secret_chk(char *argv[])
  542. {
  543.     return secret_chk(argv[0]);
  544. }
  545. int    MSG_xmodem_up(char *argv[])
  546. {
  547.     return XMODEM_upload(*argv);
  548. }
  549. int    MSG_xmodem_down(char *argv[])
  550. {
  551.     return XMODEM_download(*argv);
  552. }
  553. int    MSG_file_up(char *argv[])
  554. {
  555.     int fg = FALSE;
  556.  
  557.     while ( fg == FALSE && *argv != NULL )
  558.     fg = FILE_upload(*(argv++));
  559.     return fg;
  560. }
  561. int    MSG_memo(char *argv[])
  562. {
  563.     MEMO_insrt(atoi(argv[0]),atoi(argv[1]));
  564.     return FALSE;
  565. }
  566. int    MSG_memo_get(char *argv[])
  567. {
  568.     macset(argv[0],MEMO_get_buf());
  569.     return FALSE;
  570. }
  571. int    MSG_memo_set(char *argv[])
  572. {
  573.     MEMO_set_word(argv[0]);
  574.     MEMO_chk();
  575.     return FALSE;
  576. }
  577. int    MSG_wrtstr(char *argv[])
  578. {
  579.     DSP_pause(atoi(argv[0]),atoi(argv[1]),
  580.           atoi(argv[2]),atoi(argv[3]),
  581.           argv[4]);
  582.     return FALSE;
  583. }
  584.  
  585. int    MSG_anime(char *argv[])
  586. {
  587.     DSP_anime(argv[0]);
  588.     return FALSE;
  589. }
  590. int    MSG_wild(char *argv[])
  591. {
  592.     return patmatch(argv[0],argv[1]);
  593. }
  594. int    MSG_talk_str(char *argv[])
  595. {
  596.     while ( *argv != NULL )
  597.     TALK_str(*(argv++));
  598.     return FALSE;
  599. }
  600. int    MSG_talk_new(char *argv[])
  601. {
  602.     TALK_new(argv[0],argv[1]);
  603.     return FALSE;
  604. }
  605. int    MSG_make_snd(char *argv[])
  606. {
  607.     return SND_make(argv[0]);
  608. }
  609. int    MSG_instr(char *argv[])
  610. {
  611.     int     n;
  612.     char    *p,*s,*t;
  613.  
  614.     t = argv[0]; n = 0;
  615.     while ( t[n] != '\0' ) {
  616.     p = &(t[n]);
  617.     s = argv[1];
  618.     while ( *s != '\0' && *(p++) == *(s++) );
  619.     if ( *s == '\0' )
  620.         return n;
  621.     n++;
  622.     }
  623.     return (-1);
  624. }
  625. int    MSG_palcheng(char *argv[])
  626. {
  627.     DSP_one_pal(atoi(argv[0]),
  628.     atoi(argv[1]),atoi(argv[2]),atoi(argv[3]));
  629.     return FALSE;
  630. }
  631. int    MSG_down_load(char *argv[])
  632. {
  633.     return WIN_down_start(argv[0]);
  634. }
  635. int    MSG_rsb_set()
  636. {
  637.     RSB_mode_set();
  638.     return FALSE;
  639. }
  640. int    MSG_cut_word(char *argv[])
  641. {
  642.     int     i,n;
  643.     char    *p;
  644.     char    tmp[80];
  645.  
  646.     i = atoi(argv[2]);
  647.     n = strlen(argv[1]);
  648.     if ( n < i )
  649.     i = n;
  650.     p = argv[1] + i;
  651.     n = atoi(argv[3]);
  652.     for ( i = 0 ; *p != '\0' && i < n ; i++ )
  653.     tmp[i] = *(p++);
  654.     tmp[i] = '\0';
  655.     macset(argv[0],tmp);
  656.     return n;
  657. }
  658. int    MSG_error(char *argv[])
  659. {
  660.     if ( argv[0] != NULL )
  661.     macvalset(argv[0],errno);
  662.     return errno;
  663. }
  664. int    MSG_CD_vol_set(char *argv[])
  665. {
  666.     CD_vol_set(atoi(*argv));
  667.     return FALSE;
  668. }
  669. int    MSG_CD_play_no(char *argv[])
  670. {
  671.     CD_play_no(atoi(*argv));
  672.     return FALSE;
  673. }
  674. int    MSG_chdir(char *argv[])
  675. {
  676.     char    *p;
  677.  
  678.     if ( (p = strrchr(*argv,'\\')) != NULL && *(p+1) == '\0' )
  679.     *p = '\0';
  680.     p = *argv;
  681.     if ( p[1] == ':' )
  682.     chdrv(toupper(p[0])-'A');
  683.     return chdir(p);
  684. }
  685. int    MSG_getdir(char *argv[])
  686. {
  687.     char    tmp[128];
  688.  
  689.     if ( getdir(tmp) != FALSE )
  690.     return ERR;
  691.     if ( *argv != NULL )
  692.     macset(*argv,tmp);
  693.     return FALSE;
  694. }
  695. int    MSG_mkdir(char *argv[])
  696. {
  697.     return mkdir(*argv);
  698. }
  699. int    MSG_rmdir(char *argv[])
  700. {
  701.     return rmdir(*argv);
  702. }
  703. int    MSG_mem_file(char *argv[])
  704. {
  705.     return mem_file(*argv);
  706. }
  707. int    MSG_unmem_file(char *argv[])
  708. {
  709.     unmem_file(*argv);
  710.     return FALSE;
  711. }
  712. int    MSG_break_out(void)
  713. {
  714.     RSB_break_out();
  715.     return FALSE;
  716. }
  717. int    MSG_TANGO_set(void)
  718. {
  719.     TANGO_set();
  720.     return FALSE;
  721. }
  722. int    MSG_key_func(char *argv[])
  723. {
  724.     return KEY_func_exec(*argv);
  725. }
  726. int    MSG_exit(void)
  727. {
  728.     top_event = 6;            /* Looking "WHISPER.C" !! */
  729.     return FALSE;
  730. }
  731. int    MSG_wind_gets(char *argv[])
  732. {
  733.     char    *p;
  734.     char    tmp[84];
  735.  
  736.     strcpy(tmp,WIN_get_line(atoi(argv[1]),atoi(argv[2])));
  737.     if ( (p = strchr(tmp,'\n')) != NULL )
  738.     *p = '\0';
  739.     macset(argv[0],tmp);
  740.     return FALSE;
  741. }
  742. int    MSG_wind_upload(char *argv[])
  743. {
  744.     WIN_upload(atoi(argv[0]));
  745.     return FALSE;
  746. }
  747. int    MSG_wind_child(char *argv[])
  748. {
  749.     CHILD_set(atoi(argv[0]),atoi(argv[1]));
  750.     return FALSE;
  751. }
  752.  
  753. int    MSG_run(char *str)
  754. {
  755.     static  brk_flg=FALSE;
  756.  
  757.     int     cd=0;
  758.     int     i,n;
  759.     char    *stack_bak;
  760.     char    *p,*s;
  761.     char    tmp[BUFSIZ];
  762.     char    dmy[BUFSIZ];
  763.     char    *argv[40];
  764.     static struct {
  765.     char    *name;
  766.     int    (*func)();
  767.     } func_tbl[]={
  768.     { "access",    FIL_access },
  769.     { "add",    MSG_add },
  770.     { "anime",    MSG_anime },
  771.     { "bakcol",    MSG_bakcol },
  772.     { "break_out",    MSG_break_out },
  773.     { "cd_back",    CD_back },
  774.     { "cd_menu",    CD_menu },
  775.     { "cd_next",    CD_next },
  776.     { "cd_play",    CD_play },
  777.     { "cd_play_no",    MSG_CD_play_no },
  778.     { "cd_stop",    CD_stop },
  779.     { "cd_vol_down",CD_vol_down },
  780.     { "cd_vol_set",    MSG_CD_vol_set },
  781.     { "cd_vol_up",    CD_vol_up },
  782.     { "cfg_load",    MSG_ext_cfg },
  783.     { "chdir",    MSG_chdir },
  784.     { "cmdsset",    CMDS_init },
  785.     { "color",    MSG_color },
  786.     { "command",    MSG_command },
  787.     { "complzss",    FIL_complzss },
  788.     { "copy",    FIL_copy },
  789.     { "copy_name",    FIL_copy_name },
  790.     { "cut_word",    MSG_cut_word },
  791.     { "date2day",    MSG_date_day },
  792.     { "delete",    FIL_unlink },
  793.     { "echo",    MSG_echo },
  794.     { "error",    MSG_error },
  795.     { "eup",    MSG_eup },
  796.     { "eupstop",    END_eup },
  797.     { "exit",    MSG_exit },
  798.     { "file_down",    MSG_down_load },
  799.     { "file_up",    MSG_file_up },
  800.     { "fsecret",    FIL_secret_chk },
  801.     { "gcls",    DSP_pop_tiff },
  802.     { "getdir",    MSG_getdir },
  803.     { "input",    MSG_input },
  804.     { "instr",    MSG_instr },
  805.     { "key_func",    MSG_key_func },
  806.     { "lincol",    MSG_lincol },
  807.     { "load",    FIL_load },
  808.     { "lock",    KEY_lock },
  809.     { "macset",    MAC_init },
  810.     { "make_snd",    MSG_make_snd },
  811.     { "memo",    MSG_memo },
  812.     { "memo_get",    MSG_memo_get },
  813.     { "memo_set",    MSG_memo_set },
  814.     { "mem_file",    MSG_mem_file },
  815.     { "merge",    FIL_merge },
  816.     { "mkdir",    MSG_mkdir },
  817.     { "mosget",    MSG_mos },
  818.     { "palcheng",    MSG_palcheng },
  819.     { "palette",    PLT_set },
  820.     { "pastr",    MSG_wrtstr },
  821.     { "rename",    FIL_rename },
  822.     { "rmdir",    MSG_rmdir },
  823.     { "rs_setup",    MSG_rsb_set },
  824.     { "save",    MSG_wind_save },
  825.     { "sleep",    MSG_sleep },
  826.     { "snd",    MSG_snd },
  827.     { "stmenu",    MSG_menu_state },
  828.     { "sub",    MSG_sub },
  829.     { "super",    MSG_super },
  830.     { "switch",    MSG_switch },
  831.     { "symenu",    MSG_menu_syoko },
  832.     { "system",    MSG_system },
  833.     { "tabset",    TAB_set },
  834.     { "talk_new",    MSG_talk_new },
  835.     { "talk_str",    MSG_talk_str },
  836.     { "tango",    MSG_TANGO_set },
  837.     { "tclose",    TERM_close },
  838.     { "tgetc",    TERM_getc },
  839.     { "tgets",    TERM_gets },
  840.     { "tiff",    MSG_tiff },
  841.     { "time",    MSG_get_time },
  842.     { "tmenu",    MSG_menu_tate },
  843.     { "topen",    TERM_open },
  844.     { "tpara",    TERM_para },
  845.     { "tputc",    TERM_putc },
  846.     { "tputs",    TERM_puts },
  847.     { "type",    FIL_type },
  848.     { "unlock",    KEY_unlock },
  849.     { "unmem_file",    MSG_unmem_file },
  850.     { "wait",    MSG_wait },
  851.     { "wchild",    MSG_wind_child },
  852.     { "wclose",    MSG_close_wind },
  853.     { "wfile",    MSG_wind_file },
  854.     { "wflush",    MSG_wind_flush },
  855.     { "wgets",    MSG_wind_gets },
  856.     { "wild",    MSG_wild },
  857.     { "wnewchk",    MSG_wind_wrt_chk },
  858.     { "wopen",    MSG_open_wind },
  859.     { "wputc",    MSG_wind_putc },
  860.     { "wputs",    MSG_wind_puts },
  861.     { "wsecret",    MSG_wind_secret },
  862.     { "wtype",    MSG_wind_type },
  863.     { "wupload",    MSG_wind_upload },
  864.     { "xmodem_down",MSG_xmodem_down },
  865.     { "xmodem_up",    MSG_xmodem_up },
  866.     { "yes",    MSG_yes },
  867.     { "yesno",    MSG_yesno },
  868.     { NULL,        MSG_echo }
  869.     };
  870.  
  871.     brk_flg = FALSE;
  872.  
  873.     while ( brk_flg == FALSE && *str != '\0' ) {
  874.  
  875.     str = get_word(tmp,str);
  876.  
  877.     if ( tmp[0] == '\0' ) {
  878.         str++;
  879.         continue;
  880.     }
  881.  
  882.     if ( *str == '=' ) {
  883.         str = get_string(dmy,++str);
  884.         macset(tmp,dmy);
  885.  
  886.     } else if ( *str == '+' ) {
  887.         p = macget(tmp);
  888.         strncpy(dmy,p,BUFSIZ-10); dmy[BUFSIZ-10] = '\0'; 
  889.         str = get_string(func_ptr,++str);
  890.         strncat(dmy,func_ptr,(BUFSIZ-2)-strlen(dmy));
  891.         dmy[BUFSIZ-2] = '\0';
  892.         macset(tmp,dmy);
  893.  
  894.     } else if ( *str == '-' ) {
  895.         str = get_string(dmy,++str);
  896.         for ( p = dmy ; isspace(*p) ; p++ );
  897.         s = p;
  898.         while ( *p != '\0' && !isspace(*p) ) p++;
  899.         *p = '\0';
  900.         macset(tmp,s);
  901.  
  902.     } else if ( strcmp(tmp,"if") == 0 ) {
  903.         str = cutpara(dmy,str);
  904.         if ( (p = cutcmds(str)) != NULL ) {
  905.         if ( (n = cmp_func(dmy)) != 0 ) {
  906.             *p = '\0';
  907.             cd = MSG_run(++str);
  908.             *p = '}';
  909.         }
  910.         str = p + 1;
  911.  
  912.         for ( ; ; ) {
  913.             s = get_word(tmp,str);
  914.             if ( strcmp(tmp,"else") == 0 ) {
  915.             if ( (p = cutcmds(s)) != NULL ) {
  916.                 if ( !n ) {
  917.                 *p = '\0';
  918.                 cd = MSG_run(++s);
  919.                 *p = '}';
  920.                 }
  921.                 str = p + 1;
  922.             } else
  923.                 str = s;
  924.  
  925.             } else if ( strcmp(tmp,"elseif") == 0 ) {
  926.             s = cutpara(dmy,s);
  927.             if ( (p = cutcmds(s)) != NULL ) {
  928.                 if ( !n && (n = cmp_func(dmy)) != 0 ) {
  929.                 *p = '\0';
  930.                 cd = MSG_run(++s);
  931.                 *p = '}';
  932.                 }
  933.                 str = p + 1;
  934.             } else
  935.                 str = s;
  936.  
  937.             } else
  938.             break;
  939.         }
  940.         }
  941.  
  942.     } else if ( strcmp(tmp,"while") == 0 ) {
  943.         str = cutpara(dmy,str);
  944.         if ( (p = cutcmds(str)) != NULL ) {
  945.         brk_flg = FALSE;
  946.         while ( brk_flg == FALSE && cmp_func(dmy) ) {
  947.             *p = '\0';
  948.             cd = MSG_run(str+1);
  949.             *p = '}';
  950.         }
  951.         str = p + 1;
  952.         if ( brk_flg != ERR )
  953.             brk_flg = FALSE;
  954.         }
  955.  
  956.     } else if ( strcmp(tmp,"do") == 0 ) {
  957.         str = cutpara(dmy,str);
  958.         if ( (p = cutcmds(str)) != NULL ) {
  959.         brk_flg = FALSE;
  960.         do {
  961.             *p = '\0';
  962.             cd = MSG_run(str+1);
  963.             *p = '}';
  964.         } while ( brk_flg == FALSE && cmp_func(dmy) );
  965.         str = p + 1;
  966.         if ( brk_flg != ERR )
  967.             brk_flg = FALSE;
  968.         }
  969.  
  970.     } else if ( strcmp(tmp,"return") == 0 ) {
  971.         str = cutpara(dmy,str);
  972.         get_string(tmp,dmy);
  973.         cd = atoi(tmp);
  974.         brk_flg = ERR;
  975.         break;
  976.  
  977.     } else if ( strcmp(tmp,"break") == 0 ) {
  978.         brk_flg = TRUE;
  979.         break;
  980.  
  981.     } else if ( strcmp(tmp,"shift") == 0 ) {
  982.         str = cutpara(dmy,str);
  983.         p = macget(dmy);
  984.         while ( isspace(*p) ) p++;
  985.         while ( *p != '\0' && !isspace(*p) ) p++;
  986.         while ( isspace(*p) ) p++;
  987.         strcpy(func_ptr,p);
  988.         macset(dmy,func_ptr);
  989.  
  990.     } else if ( strcmp(tmp,"inc") == 0 ) {
  991.         str = cutpara(dmy,str);
  992.         n = atoi(macget(dmy))+1;
  993.         sprintf(tmp,"%d",n);
  994.         macset(dmy,tmp);
  995.  
  996.     } else if ( strcmp(tmp,"dec") == 0 ) {
  997.         str = cutpara(dmy,str);
  998.         n = atoi(macget(dmy))-1;
  999.         sprintf(tmp,"%d",n);
  1000.         macset(dmy,tmp);
  1001.  
  1002.     } else {
  1003.         if ( strcmp(tmp,func_tbl[40].name) >= 0 )
  1004.         i = (strcmp(tmp,func_tbl[60].name) >= 0 ? 60:40);
  1005.         else
  1006.         i = (strcmp(tmp,func_tbl[20].name) >= 0 ? 20:0);
  1007.  
  1008.         for ( ; func_tbl[i].name != NULL ; i++ ) {
  1009.         if ( strcmp(tmp,func_tbl[i].name) == 0 ) {
  1010.             str = cutpara(dmy,str);
  1011.             p = dmy;
  1012.             n = 0;
  1013.             stack_bak = func_ptr;
  1014.             while ( *p != '\0' ) {
  1015.                 p = get_string(func_ptr,p);
  1016.             argv[n++] = func_ptr;
  1017.             while ( func_ptr < &(func_buf[FUNC_MAX-2]) ) {
  1018.                 if ( *(func_ptr++) == '\0' )
  1019.                 break;
  1020.             }
  1021.             if ( *p == ',' ) p++;
  1022.             }
  1023.             argv[n] = NULL;
  1024.             cd = (*(func_tbl[i].func))(argv);
  1025.             func_ptr = stack_bak;
  1026.             sprintf(tmp,"%d",cd);
  1027.             macset("VAL",tmp);
  1028.             break;
  1029.         }
  1030.         }
  1031.         if ( func_tbl[i].name == NULL ) {
  1032.         p = prcget(tmp);
  1033.         str = cutpara(dmy,str);
  1034.         get_string(tmp,dmy);
  1035.         macset("PARA",tmp);
  1036.         cd = MSG_run(p);
  1037.         sprintf(tmp,"%d",cd);
  1038.         macset("VAL",tmp);
  1039.         brk_flg = FALSE;
  1040.         }
  1041.     }
  1042.     }
  1043.     return cd;
  1044. }
  1045.