Unified · Split
| @@ -226,9 +226,11 @@ E_COMPUTE_OPERATION_GET_B=42, · 225 unmodified lines | ||
| 226 | 226 | E_COMPUTE_OPERATION_SET_R=43, |
| 227 | 227 | E_COMPUTE_OPERATION_SET_V=44, |
| 228 | 228 | E_COMPUTE_OPERATION_SET_B=45, |
| 229 | +E_COMPUTE_OPERATION_SOFT2HARD=46, | |
| 230 | +E_COMPUTE_OPERATION_HARD2SOFT=47, | |
| 229 | 231 | /* string functions */ |
| 230 | −E_COMPUTE_OPERATION_GETNOP=46, | |
| 231 | −E_COMPUTE_OPERATION_END=47 | |
| 232 | +E_COMPUTE_OPERATION_GETNOP=48, | |
| 233 | +E_COMPUTE_OPERATION_END=49 | |
| 232 | 234 | }; |
| 233 | 235 | |
| 234 | 236 | struct s_compute_element { |
| @@ -966,6 +968,10 @@ struct s_math_keyword math_keyword[]={ · 731 unmodified lines | ||
| 966 | 968 | {"SETV",0,E_COMPUTE_OPERATION_SET_V}, |
| 967 | 969 | {"SETG",0,E_COMPUTE_OPERATION_SET_V}, |
| 968 | 970 | {"SETB",0,E_COMPUTE_OPERATION_SET_B}, |
| 971 | +{"SOFT2HARD_INK",0,E_COMPUTE_OPERATION_SOFT2HARD}, | |
| 972 | +{"S2H_INK",0,E_COMPUTE_OPERATION_SOFT2HARD}, | |
| 973 | +{"HARD2SOFT_INK",0,E_COMPUTE_OPERATION_HARD2SOFT}, | |
| 974 | +{"H2S_INK",0,E_COMPUTE_OPERATION_HARD2SOFT}, | |
| 969 | 975 | {"GETNOP",0,E_COMPUTE_OPERATION_GETNOP}, |
| 970 | 976 | {"",0,-1} |
| 971 | 977 | }; |
| @@ -3636,11 +3642,84 @@ int __GETNOP(struct s_assenv *ae,char *opcode, int didx) · 2664 unmodified lines | ||
| 3636 | 3642 | case CRC_JR: |
| 3637 | 3643 | case CRC_RET:tick=3;break; |
| 3638 | 3644 | default: |
| 3639 | − MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"unsupported opcode [%s] for TICK, see documentation about this directive",opcode); | |
| 3645 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"unsupported opcode [%s] for GETNOP, see documentation about this directive",opcode); | |
| 3640 | 3646 | } |
| 3641 | 3647 | return tick; |
| 3642 | 3648 | } |
| 3643 | 3649 | |
| 3650 | +int __Soft2HardInk(struct s_assenv *ae,int soft, int didx) { | |
| 3651 | + switch (soft) { | |
| 3652 | + case 0:return 64+20;break; | |
| 3653 | + case 1:return 64+4 ;break; | |
| 3654 | + case 2:return 64+21 ;break; | |
| 3655 | + case 3:return 64+28 ;break; | |
| 3656 | + case 4:return 64+24 ;break; | |
| 3657 | + case 5:return 64+29 ;break; | |
| 3658 | + case 6:return 64+12 ;break; | |
| 3659 | + case 7:return 64+5 ;break; | |
| 3660 | + case 8:return 64+13 ;break; | |
| 3661 | + case 9:return 64+22 ;break; | |
| 3662 | + case 10:return 64+6 ;break; | |
| 3663 | + case 11:return 64+23 ;break; | |
| 3664 | + case 12:return 64+30 ;break; | |
| 3665 | + case 13:return 64+0 ;break; | |
| 3666 | + case 14:return 64+31 ;break; | |
| 3667 | + case 15:return 64+14 ;break; | |
| 3668 | + case 16:return 64+7 ;break; | |
| 3669 | + case 17:return 64+15 ;break; | |
| 3670 | + case 18:return 64+18 ;break; | |
| 3671 | + case 19:return 64+2 ;break; | |
| 3672 | + case 20:return 64+19 ;break; | |
| 3673 | + case 21:return 64+26 ;break; | |
| 3674 | + case 22:return 64+25 ;break; | |
| 3675 | + case 23:return 64+27 ;break; | |
| 3676 | + case 24:return 64+10 ;break; | |
| 3677 | + case 25:return 64+3 ;break; | |
| 3678 | + case 26:return 64+11 ;break; | |
| 3679 | + default: | |
| 3680 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"SOFT2HARD_INK needs 0-26 color index"); | |
| 3681 | + } | |
| 3682 | + return 0; | |
| 3683 | +} | |
| 3684 | +int __Hard2SoftInk(struct s_assenv *ae,int hard, int didx) { | |
| 3685 | + hard&=31; | |
| 3686 | + switch (hard) { | |
| 3687 | + case 0:return 13;break; | |
| 3688 | + case 1:return 13;break; | |
| 3689 | + case 2:return 19;break; | |
| 3690 | + case 3:return 25;break; | |
| 3691 | + case 4:return 1;break; | |
| 3692 | + case 5:return 7;break; | |
| 3693 | + case 6:return 10;break; | |
| 3694 | + case 7:return 16;break; | |
| 3695 | + case 8:return 7;break; | |
| 3696 | + case 9:return 25;break; | |
| 3697 | + case 10:return 24;break; | |
| 3698 | + case 11:return 26;break; | |
| 3699 | + case 12:return 6;break; | |
| 3700 | + case 13:return 8;break; | |
| 3701 | + case 14:return 15;break; | |
| 3702 | + case 15:return 17;break; | |
| 3703 | + case 16:return 1;break; | |
| 3704 | + case 17:return 19;break; | |
| 3705 | + case 18:return 18;break; | |
| 3706 | + case 19:return 20;break; | |
| 3707 | + case 20:return 0;break; | |
| 3708 | + case 21:return 2;break; | |
| 3709 | + case 22:return 9;break; | |
| 3710 | + case 23:return 11;break; | |
| 3711 | + case 24:return 4;break; | |
| 3712 | + case 25:return 22;break; | |
| 3713 | + case 26:return 21;break; | |
| 3714 | + case 27:return 23;break; | |
| 3715 | + case 28:return 3;break; | |
| 3716 | + case 29:return 5;break; | |
| 3717 | + case 30:return 12;break; | |
| 3718 | + case 31:return 14;break; | |
| 3719 | + default:/*warning remover*/break; | |
| 3720 | + } | |
| 3721 | + return 0; | |
| 3722 | +} | |
| 3644 | 3723 | |
| 3645 | 3724 | double ComputeExpressionCore(struct s_assenv *ae,char *original_zeexpression,int ptr, int didx) |
| 3646 | 3725 | { |
| @@ -3689,16 +3768,6 @@ double ComputeExpressionCore(struct s_assenv *ae,char *original_zeexpression,int · 42 unmodified lines | ||
| 3689 | 3768 | accu=NULL;maccu=0; |
| 3690 | 3769 | if (maxcomputestack) MemFree(computestack); |
| 3691 | 3770 | computestack=NULL;maxcomputestack=0; |
| 3692 | −#if 0 | |
| 3693 | − if (maxivar) MemFree(varbuffer); | |
| 3694 | − if (maxtokenstack) MemFree(tokenstack); | |
| 3695 | − if (maxoperatorstack) MemFree(operatorstack); | |
| 3696 | − maxtokenstack=maxoperatorstack=0; | |
| 3697 | − maxivar=1; | |
| 3698 | − varbuffer=NULL; | |
| 3699 | − tokenstack=NULL; | |
| 3700 | − operatorstack=NULL; | |
| 3701 | −#endif | |
| 3702 | 3771 | return 0.0; |
| 3703 | 3772 | } |
| 3704 | 3773 | |
| @@ -3994,6 +4063,7 @@ double ComputeExpressionCore(struct s_assenv *ae,char *original_zeexpression,int · 289 unmodified lines | ||
| 3994 | 4063 | MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"expression [%s] has unknown operator %c (%d)\n",TradExpression(zeexpression),c>31?c:'.',c); |
| 3995 | 4064 | } |
| 3996 | 4065 | /* stackelement.value isn't used */ |
| 4066 | + stackelement.string=NULL; | |
| 3997 | 4067 | } else if (is_string) { |
| 3998 | 4068 | stackelement.operator=E_COMPUTE_OPERATION_PUSH_DATASTC; |
| 3999 | 4069 | /* priority & value isn't used */ |
| @@ -4172,7 +4242,7 @@ double ComputeExpressionCore(struct s_assenv *ae,char *original_zeexpression,int · 172 unmodified lines | ||
| 4172 | 4242 | if (c=='(') { |
| 4173 | 4243 | /* push function as operator! */ |
| 4174 | 4244 | stackelement.operator=math_keyword[imkey].operation; |
| 4175 | − //stackelement.priority=0; | |
| 4245 | + stackelement.string=NULL; | |
| 4176 | 4246 | /************************************************ |
| 4177 | 4247 | C R E A T E E X T R A T O K E N |
| 4178 | 4248 | ************************************************/ |
| @@ -4575,7 +4645,7 @@ printf("stage 2 | page=%d | ptr=%X ibank=%d\n",page,curlabel->ptr,curlabel->iban · 396 unmodified lines | ||
| 4575 | 4645 | #if DEBUG_STACK |
| 4576 | 4646 | for (itoken=0;itoken<nbtokenstack;itoken++) { |
| 4577 | 4647 | switch (ae->computectx->tokenstack[itoken].operator) { |
| 4578 | − case E_COMPUTE_OPERATION_PUSH_DATASTC:printf("%lf ",ae->computectx->tokenstack[itoken].value);break; | |
| 4648 | + case E_COMPUTE_OPERATION_PUSH_DATASTC:printf("%lf %s",ae->computectx->tokenstack[itoken].value,ae->computectx->tokenstack[itoken].string?ae->computectx->tokenstack[itoken].string:"(null)");break; | |
| 4579 | 4649 | case E_COMPUTE_OPERATION_OPEN:printf("(");break; |
| 4580 | 4650 | case E_COMPUTE_OPERATION_CLOSE:printf(")");break; |
| 4581 | 4651 | case E_COMPUTE_OPERATION_ADD:printf("+ ");break; |
| @@ -4621,6 +4691,8 @@ printf("stage 2 | page=%d | ptr=%X ibank=%d\n",page,curlabel->ptr,curlabel->iban · 39 unmodified lines | ||
| 4621 | 4691 | case E_COMPUTE_OPERATION_SET_R:printf("set_r ");break; |
| 4622 | 4692 | case E_COMPUTE_OPERATION_SET_V:printf("set_v ");break; |
| 4623 | 4693 | case E_COMPUTE_OPERATION_SET_B:printf("set_b ");break; |
| 4694 | + case E_COMPUTE_OPERATION_SOFT2HARD:printf("soft2hard ");break; | |
| 4695 | + case E_COMPUTE_OPERATION_HARD2SOFT:printf("hard2soft ");break; | |
| 4624 | 4696 | case E_COMPUTE_OPERATION_GETNOP:printf("getnop ");break; |
| 4625 | 4697 | default:printf("bug\n");break; |
| 4626 | 4698 | } |
| @@ -4633,14 +4705,14 @@ printf("stage 2 | page=%d | ptr=%X ibank=%d\n",page,curlabel->ptr,curlabel->iban · 6 unmodified lines | ||
| 4633 | 4705 | switch (ae->computectx->tokenstack[itoken].operator) { |
| 4634 | 4706 | case E_COMPUTE_OPERATION_PUSH_DATASTC: |
| 4635 | 4707 | #if DEBUG_STACK |
| 4636 | −printf("data\n"); | |
| 4708 | +printf("data string=%X\n",ae->computectx->tokenstack[itoken].string); | |
| 4637 | 4709 | #endif |
| 4638 | 4710 | ObjectArrayAddDynamicValueConcat((void **)&computestack,&nbcomputestack,&maxcomputestack,&ae->computectx->tokenstack[itoken],sizeof(stackelement)); |
| 4639 | 4711 | break; |
| 4640 | 4712 | case E_COMPUTE_OPERATION_OPEN: |
| 4641 | 4713 | ObjectArrayAddDynamicValueConcat((void **)&ae->computectx->operatorstack,&nboperatorstack,&ae->computectx->maxoperatorstack,&ae->computectx->tokenstack[itoken],sizeof(stackelement)); |
| 4642 | 4714 | #if DEBUG_STACK |
| 4643 | −printf("ajout (\n"); | |
| 4715 | +printf("ajout ( string=%X\n",ae->computectx->tokenstack[itoken].string); | |
| 4644 | 4716 | #endif |
| 4645 | 4717 | break; |
| 4646 | 4718 | case E_COMPUTE_OPERATION_CLOSE: |
| @@ -4655,7 +4727,7 @@ printf("close\n"); · 8 unmodified lines | ||
| 4655 | 4727 | ObjectArrayAddDynamicValueConcat((void **)&computestack,&nbcomputestack,&maxcomputestack,&ae->computectx->operatorstack[o2],sizeof(stackelement)); |
| 4656 | 4728 | nboperatorstack--; |
| 4657 | 4729 | #if DEBUG_STACK |
| 4658 | −printf("op--\n"); | |
| 4730 | +printf("op-- string=%X\n",ae->computectx->operatorstack[o2].string); | |
| 4659 | 4731 | #endif |
| 4660 | 4732 | o2--; |
| 4661 | 4733 | } else { |
| @@ -4681,7 +4753,7 @@ printf("discard )\n"); · 19 unmodified lines | ||
| 4681 | 4753 | ObjectArrayAddDynamicValueConcat((void **)&computestack,&nbcomputestack,&maxcomputestack,&ae->computectx->operatorstack[o2],sizeof(stackelement)); |
| 4682 | 4754 | nboperatorstack--; |
| 4683 | 4755 | #if DEBUG_STACK |
| 4684 | −printf("pop function\n"); | |
| 4756 | +printf("pop function string=%X\n",ae->computectx->operatorstack[o2].string); | |
| 4685 | 4757 | #endif |
| 4686 | 4758 | } |
| 4687 | 4759 | break; |
| @@ -4704,13 +4776,13 @@ printf("pop function\n"); · 16 unmodified lines | ||
| 4704 | 4776 | case E_COMPUTE_OPERATION_NOTEQUAL: |
| 4705 | 4777 | case E_COMPUTE_OPERATION_LOWEREQ: |
| 4706 | 4778 | case E_COMPUTE_OPERATION_GREATEREQ: |
| 4707 | −#if DEBUG_STACK | |
| 4708 | −printf("operator\n"); | |
| 4709 | −#endif | |
| 4710 | 4779 | o2=nboperatorstack-1; |
| 4711 | 4780 | while (o2>=0 && ae->computectx->operatorstack[o2].operator!=E_COMPUTE_OPERATION_OPEN) { |
| 4712 | 4781 | if (ae->computectx->tokenstack[itoken].priority>=ae->computectx->operatorstack[o2].priority || ae->computectx->operatorstack[o2].operator>=E_COMPUTE_OPERATION_SIN) { |
| 4713 | 4782 | ObjectArrayAddDynamicValueConcat((void **)&computestack,&nbcomputestack,&maxcomputestack,&ae->computectx->operatorstack[o2],sizeof(stackelement)); |
| 4783 | +#if DEBUG_STACK | |
| 4784 | +printf("operator string=%X\n",ae->computectx->operatorstack[o2].string); | |
| 4785 | +#endif | |
| 4714 | 4786 | nboperatorstack--; |
| 4715 | 4787 | o2--; |
| 4716 | 4788 | } else { |
| @@ -4743,6 +4815,8 @@ printf("operator\n"); · 26 unmodified lines | ||
| 4743 | 4815 | case E_COMPUTE_OPERATION_SET_R: |
| 4744 | 4816 | case E_COMPUTE_OPERATION_SET_V: |
| 4745 | 4817 | case E_COMPUTE_OPERATION_SET_B: |
| 4818 | + case E_COMPUTE_OPERATION_SOFT2HARD: | |
| 4819 | + case E_COMPUTE_OPERATION_HARD2SOFT: | |
| 4746 | 4820 | case E_COMPUTE_OPERATION_GETNOP: |
| 4747 | 4821 | #if DEBUG_STACK |
| 4748 | 4822 | printf("ajout de la fonction\n"); |
| @@ -4755,6 +4829,9 @@ printf("ajout de la fonction\n"); · 6 unmodified lines | ||
| 4755 | 4829 | /* pop remaining operators */ |
| 4756 | 4830 | while (nboperatorstack>0) { |
| 4757 | 4831 | ObjectArrayAddDynamicValueConcat((void **)&computestack,&nbcomputestack,&maxcomputestack,&ae->computectx->operatorstack[--nboperatorstack],sizeof(stackelement)); |
| 4832 | +#if DEBUG_STACK | |
| 4833 | +printf("final POP string=%X\n",ae->computectx->operatorstack[nboperatorstack+1].string); | |
| 4834 | +#endif | |
| 4758 | 4835 | } |
| 4759 | 4836 | |
| 4760 | 4837 | /******************************************** |
| @@ -4773,7 +4850,13 @@ printf("ajout de la fonction\n"); · 12 unmodified lines | ||
| 4773 | 4850 | maccu=16+paccu; |
| 4774 | 4851 | accu=MemRealloc(accu,sizeof(double)*maccu); |
| 4775 | 4852 | } |
| 4776 | − accu[paccu]=computestack[i].value;paccu++; | |
| 4853 | + if (computestack[i].string) { | |
| 4854 | + /* string hack */ | |
| 4855 | + accu[paccu]=i+0.1; | |
| 4856 | + } else { | |
| 4857 | + accu[paccu]=computestack[i].value; | |
| 4858 | + } | |
| 4859 | + paccu++; | |
| 4777 | 4860 | break; |
| 4778 | 4861 | case E_COMPUTE_OPERATION_OPEN: |
| 4779 | 4862 | case E_COMPUTE_OPERATION_CLOSE:/* cannot happend */ break; |
| @@ -4837,6 +4920,28 @@ printf("ajout de la fonction\n"); · 57 unmodified lines | ||
| 4837 | 4920 | case E_COMPUTE_OPERATION_SET_R:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15)<<4;break; |
| 4838 | 4921 | case E_COMPUTE_OPERATION_SET_V:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15)<<8;break; |
| 4839 | 4922 | case E_COMPUTE_OPERATION_SET_B:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15);break; |
| 4923 | + case E_COMPUTE_OPERATION_SOFT2HARD:if (paccu>0) accu[paccu-1]=__Soft2HardInk(ae,accu[paccu-1],didx);break; | |
| 4924 | + case E_COMPUTE_OPERATION_HARD2SOFT:if (paccu>0) accu[paccu-1]=__Hard2SoftInk(ae,accu[paccu-1],didx);break; | |
| 4925 | + /* functions with strings */ | |
| 4926 | + case E_COMPUTE_OPERATION_GETNOP:if (paccu>0) { | |
| 4927 | + int integeridx; | |
| 4928 | + integeridx=floor(accu[paccu-1]); | |
| 4929 | + | |
| 4930 | + if (integeridx>=0 && integeridx<nbcomputestack && computestack[integeridx].string) { | |
| 4931 | + accu[paccu-1]=__GETNOP(ae,computestack[integeridx].string,didx); | |
| 4932 | + MemFree(computestack[integeridx].string); | |
| 4933 | + computestack[integeridx].string=NULL; | |
| 4934 | + } else { | |
| 4935 | + if (integeridx>=0 && integeridx<nbcomputestack) { | |
| 4936 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP function needs a proper string\n"); | |
| 4937 | + } else { | |
| 4938 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP internal error (wrong string index)\n"); | |
| 4939 | + } | |
| 4940 | + } | |
| 4941 | + } else { | |
| 4942 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP is empty\n"); | |
| 4943 | + } | |
| 4944 | + break; | |
| 4840 | 4945 | default:MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"invalid computing state! (%d)\n",computestack[i].operator);paccu=0; |
| 4841 | 4946 | } |
| 4842 | 4947 | if (!paccu) { |
| @@ -4954,15 +5059,26 @@ printf("ajout de la fonction\n"); · 111 unmodified lines | ||
| 4954 | 5059 | case E_COMPUTE_OPERATION_SET_R:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15)<<4;break; |
| 4955 | 5060 | case E_COMPUTE_OPERATION_SET_V:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15)<<8;break; |
| 4956 | 5061 | case E_COMPUTE_OPERATION_SET_B:if (paccu>0) accu[paccu-1]=MinMaxInt(accu[paccu-1],0,15);break; |
| 5062 | + case E_COMPUTE_OPERATION_SOFT2HARD:if (paccu>0) accu[paccu-1]=__Soft2HardInk(ae,accu[paccu-1],didx);break; | |
| 5063 | + case E_COMPUTE_OPERATION_HARD2SOFT:if (paccu>0) accu[paccu-1]=__Hard2SoftInk(ae,accu[paccu-1],didx);break; | |
| 4957 | 5064 | /* functions with strings */ |
| 4958 | 5065 | case E_COMPUTE_OPERATION_GETNOP:if (paccu>0) { |
| 4959 | 5066 | int integeridx; |
| 4960 | − integeridx=accu[paccu-1]; | |
| 4961 | − //printf("GETNOP(%s)\n",computestack[integeridx].string); | |
| 4962 | − | |
| 4963 | − accu[paccu-1]=__GETNOP(ae,computestack[integeridx].string,didx); | |
| 4964 | − MemFree(computestack[integeridx].string); | |
| 4965 | − computestack[integeridx].string=NULL; | |
| 5067 | + integeridx=floor(accu[paccu-1]); | |
| 5068 | + | |
| 5069 | + if (integeridx>=0 && integeridx<nbcomputestack && computestack[integeridx].string) { | |
| 5070 | + accu[paccu-1]=__GETNOP(ae,computestack[integeridx].string,didx); | |
| 5071 | + MemFree(computestack[integeridx].string); | |
| 5072 | + computestack[integeridx].string=NULL; | |
| 5073 | + } else { | |
| 5074 | + if (integeridx>=0 && integeridx<nbcomputestack) { | |
| 5075 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP function needs a proper string\n"); | |
| 5076 | + } else { | |
| 5077 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP internal error (wrong string index)\n"); | |
| 5078 | + } | |
| 5079 | + } | |
| 5080 | + } else { | |
| 5081 | + MakeError(ae,GetExpFile(ae,didx),GetExpLine(ae,didx),"GETNOP is empty\n"); | |
| 4966 | 5082 | } |
| 4967 | 5083 | break; |
| 4968 | 5084 | default:MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"invalid computing state! (%d)\n",computestack[i].operator);paccu=0; |
| @@ -11093,9 +11209,215 @@ void __BREAKPOINT(struct s_assenv *ae) { · 6124 unmodified lines | ||
| 11093 | 11209 | MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"syntax is BREAKPOINT [adress]\n"); |
| 11094 | 11210 | } |
| 11095 | 11211 | } |
| 11212 | + | |
| 11213 | + | |
| 11214 | +void __SNASET(struct s_assenv *ae) { | |
| 11215 | + int myvalue,idx; | |
| 11216 | + | |
| 11217 | + if (!ae->forcecpr && !ae->forcetape && !ae->forcezx) { | |
| 11218 | + ae->forcesnapshot=1; | |
| 11219 | + } else { | |
| 11220 | + if (!ae->nowarning) { | |
| 11221 | + rasm_printf(ae,KWARNING"[%s:%d] Warning: Cannot SNASET when already in cartridge/tape output\n",GetCurrentFile(ae),ae->wl[ae->idx].l); | |
| 11222 | + if (ae->erronwarn) MaxError(ae); | |
| 11223 | + } | |
| 11224 | + } | |
| 11225 | + | |
| 11226 | + if (!ae->wl[ae->idx].t) { | |
| 11227 | + ae->idx++; | |
| 11228 | + /* TWO parameters */ | |
| 11229 | + if (!ae->wl[ae->idx].t && ae->wl[ae->idx+1].t==1) { | |
| 11230 | + /* parameter value */ | |
| 11231 | + ExpressionFastTranslate(ae,&ae->wl[ae->idx+1].w,0); | |
| 11232 | + myvalue=RoundComputeExpression(ae,ae->wl[ae->idx+1].w,ae->codeadr,0,0); | |
| 11233 | + | |
| 11234 | + /* Z80 register/value */ | |
| 11235 | + if (strcmp(ae->wl[ae->idx].w,"Z80_AF")==0) { | |
| 11236 | + ae->snapshot.registers.general.F=myvalue&0xFF; | |
| 11237 | + ae->snapshot.registers.general.A=(myvalue>>8)&0xFF; | |
| 11238 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_F")==0) { | |
| 11239 | + ae->snapshot.registers.general.F=myvalue; | |
| 11240 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_A")==0) { | |
| 11241 | + ae->snapshot.registers.general.A=myvalue; | |
| 11242 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_BC")==0) { | |
| 11243 | + ae->snapshot.registers.general.C=myvalue&0xFF; | |
| 11244 | + ae->snapshot.registers.general.B=(myvalue>>8)&0xFF; | |
| 11245 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_C")==0) { | |
| 11246 | + ae->snapshot.registers.general.C=myvalue; | |
| 11247 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_B")==0) { | |
| 11248 | + ae->snapshot.registers.general.B=myvalue; | |
| 11249 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_DE")==0) { | |
| 11250 | + ae->snapshot.registers.general.E=myvalue&0xFF; | |
| 11251 | + ae->snapshot.registers.general.D=(myvalue>>8)&0xFF; | |
| 11252 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_E")==0) { | |
| 11253 | + ae->snapshot.registers.general.E=myvalue; | |
| 11254 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_D")==0) { | |
| 11255 | + ae->snapshot.registers.general.D=myvalue; | |
| 11256 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_HL")==0) { | |
| 11257 | + ae->snapshot.registers.general.L=myvalue&0xFF; | |
| 11258 | + ae->snapshot.registers.general.H=(myvalue>>8)&0xFF; | |
| 11259 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_L")==0) { | |
| 11260 | + ae->snapshot.registers.general.L=myvalue; | |
| 11261 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_H")==0) { | |
| 11262 | + ae->snapshot.registers.general.H=myvalue; | |
| 11263 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_I")==0) { | |
| 11264 | + ae->snapshot.registers.regI=myvalue; | |
| 11265 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_R")==0) { | |
| 11266 | + ae->snapshot.registers.R=myvalue; | |
| 11267 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IFF0")==0) { | |
| 11268 | + ae->snapshot.registers.IFF0=myvalue; | |
| 11269 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IFF1")==0) { | |
| 11270 | + ae->snapshot.registers.IFF1=myvalue; | |
| 11271 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IX")==0) { | |
| 11272 | + ae->snapshot.registers.LX=myvalue&0xFF; | |
| 11273 | + ae->snapshot.registers.HX=(myvalue>>8)&0xFF; | |
| 11274 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IXL")==0) { | |
| 11275 | + ae->snapshot.registers.LX=myvalue; | |
| 11276 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IXH")==0) { | |
| 11277 | + ae->snapshot.registers.HX=myvalue; | |
| 11278 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IY")==0) { | |
| 11279 | + ae->snapshot.registers.LY=myvalue&0xFF; | |
| 11280 | + ae->snapshot.registers.HY=(myvalue>>8)&0xFF; | |
| 11281 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IYL")==0) { | |
| 11282 | + ae->snapshot.registers.LY=myvalue; | |
| 11283 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IYH")==0) { | |
| 11284 | + ae->snapshot.registers.HY=myvalue; | |
| 11285 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_SP")==0) { | |
| 11286 | + ae->snapshot.registers.LSP=myvalue&0xFF; | |
| 11287 | + ae->snapshot.registers.HSP=(myvalue>>8)&0xFF; | |
| 11288 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_PC")==0) { | |
| 11289 | + ae->snapshot.registers.LPC=myvalue&0xFF; | |
| 11290 | + ae->snapshot.registers.HPC=(myvalue>>8)&0xFF; | |
| 11291 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_IM")==0) { | |
| 11292 | + ae->snapshot.registers.IM=myvalue; | |
| 11293 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_AFX")==0) { | |
| 11294 | + ae->snapshot.registers.alternate.F=myvalue&0xFF; | |
| 11295 | + ae->snapshot.registers.alternate.A=(myvalue>>8)&0xFF; | |
| 11296 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_AX")==0) { | |
| 11297 | + ae->snapshot.registers.alternate.A=myvalue; | |
| 11298 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_FX")==0) { | |
| 11299 | + ae->snapshot.registers.alternate.F=myvalue; | |
| 11300 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_BCX")==0) { | |
| 11301 | + ae->snapshot.registers.alternate.C=myvalue&0xFF; | |
| 11302 | + ae->snapshot.registers.alternate.B=(myvalue>>8)&0xFF; | |
| 11303 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_CX")==0) { | |
| 11304 | + ae->snapshot.registers.alternate.C=myvalue; | |
| 11305 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_BX")==0) { | |
| 11306 | + ae->snapshot.registers.alternate.B=myvalue; | |
| 11307 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_DEX")==0) { | |
| 11308 | + ae->snapshot.registers.alternate.E=myvalue&0xFF; | |
| 11309 | + ae->snapshot.registers.alternate.D=(myvalue>>8)&0xFF; | |
| 11310 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_EX")==0) { | |
| 11311 | + ae->snapshot.registers.alternate.E=myvalue; | |
| 11312 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_DX")==0) { | |
| 11313 | + ae->snapshot.registers.alternate.D=myvalue; | |
| 11314 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_HLX")==0) { | |
| 11315 | + ae->snapshot.registers.alternate.L=myvalue&0xFF; | |
| 11316 | + ae->snapshot.registers.alternate.H=(myvalue>>8)&0xFF; | |
| 11317 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_LX")==0) { | |
| 11318 | + ae->snapshot.registers.alternate.L=myvalue; | |
| 11319 | + } else if (strcmp(ae->wl[ae->idx].w,"Z80_HX")==0) { | |
| 11320 | + ae->snapshot.registers.alternate.H=myvalue; | |
| 11321 | + /* Gate Array / CRTC / PPI / FDD */ | |
| 11322 | + } else if (strcmp(ae->wl[ae->idx].w,"GA_PEN")==0) { | |
| 11323 | + ae->snapshot.gatearray.selectedpen=myvalue; | |
| 11324 | + } else if (strcmp(ae->wl[ae->idx].w,"GA_ROMCFG")==0) { | |
| 11325 | + ae->snapshot.gatearray.multiconfiguration=myvalue; | |
| 11326 | + } else if (strcmp(ae->wl[ae->idx].w,"GA_RAMCFG")==0) { | |
| 11327 | + ae->snapshot.ramconfiguration=myvalue; | |
| 11328 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_SEL")==0) { | |
| 11329 | + ae->snapshot.crtc.selectedregister=myvalue; | |
| 11330 | + } else if (strcmp(ae->wl[ae->idx].w,"ROM_UP")==0) { | |
| 11331 | + ae->snapshot.romselect=myvalue; | |
| 11332 | + } else if (strcmp(ae->wl[ae->idx].w,"PPI_A")==0) { | |
| 11333 | + ae->snapshot.ppi.portA=myvalue; | |
| 11334 | + } else if (strcmp(ae->wl[ae->idx].w,"PPI_B")==0) { | |
| 11335 | + ae->snapshot.ppi.portB=myvalue; | |
| 11336 | + } else if (strcmp(ae->wl[ae->idx].w,"PPI_C")==0) { | |
| 11337 | + ae->snapshot.ppi.portC=myvalue; | |
| 11338 | + } else if (strcmp(ae->wl[ae->idx].w,"PPI_CTL")==0) { | |
| 11339 | + ae->snapshot.ppi.control=myvalue; | |
| 11340 | + } else if (strcmp(ae->wl[ae->idx].w,"PSG_SEL")==0) { | |
| 11341 | + ae->snapshot.psg.selectedregister=myvalue; | |
| 11342 | + } else if (strcmp(ae->wl[ae->idx].w,"CPC_TYPE")==0) { | |
| 11343 | + ae->snapshot.CPCType=myvalue; | |
| 11344 | + } else if (strcmp(ae->wl[ae->idx].w,"INT_NUM")==0) { | |
| 11345 | + ae->snapshot.interruptnumber=myvalue; | |
| 11346 | + } else if (strcmp(ae->wl[ae->idx].w,"FDD_MOTOR")==0) { | |
| 11347 | + ae->snapshot.fdd.motorstate=myvalue; | |
| 11348 | + } else if (strcmp(ae->wl[ae->idx].w,"FDD_TRACK")==0) { | |
| 11349 | + ae->snapshot.fdd.physicaltrack=myvalue; | |
| 11350 | + } else if (strcmp(ae->wl[ae->idx].w,"PRNT_DATA")==0) { | |
| 11351 | + ae->snapshot.printerstrobe=myvalue; | |
| 11352 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_TYPE")==0) { | |
| 11353 | + ae->snapshot.crtcstate.model=myvalue; | |
| 11354 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_HCC")==0) { | |
| 11355 | + ae->snapshot.crtcstate.HCC=myvalue; | |
| 11356 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_CLC")==0) { | |
| 11357 | + ae->snapshot.crtcstate.CLC=myvalue; | |
| 11358 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_RLC")==0) { | |
| 11359 | + ae->snapshot.crtcstate.RLC=myvalue; | |
| 11360 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_VAC")==0) { // Vertical Total Adjust Counter | |
| 11361 | + ae->snapshot.crtcstate.VTC=myvalue; | |
| 11362 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_HSWC")==0) { | |
| 11363 | + ae->snapshot.crtcstate.HSC=myvalue; | |
| 11364 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_VSWC")==0) { | |
| 11365 | + ae->snapshot.crtcstate.VSC=myvalue; | |
| 11366 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_STATE")==0) { | |
| 11367 | + ae->snapshot.crtcstate.flags=myvalue; | |
| 11368 | + } else if (strcmp(ae->wl[ae->idx].w,"GA_VSC")==0) { | |
| 11369 | + ae->snapshot.vsyncdelay=myvalue; | |
| 11370 | + } else if (strcmp(ae->wl[ae->idx].w,"GA_ISC")==0) { | |
| 11371 | + ae->snapshot.interruptscanlinecounter=myvalue; | |
| 11372 | + } else if (strcmp(ae->wl[ae->idx].w,"INT_REQ")==0) { | |
| 11373 | + ae->snapshot.interruptrequestflag=myvalue; | |
| 11374 | + } else { | |
| 11375 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive unknown non array settings\n"); | |
| 11376 | + } | |
| 11377 | + } else if (!ae->wl[ae->idx].t && !ae->wl[ae->idx+1].t && ae->wl[ae->idx+2].t==1) { | |
| 11378 | + /* index value */ | |
| 11379 | + ExpressionFastTranslate(ae,&ae->wl[ae->idx+1].w,0); | |
| 11380 | + idx=RoundComputeExpression(ae,ae->wl[ae->idx+1].w,ae->codeadr,0,0); | |
| 11381 | + | |
| 11382 | + /* parameter value */ | |
| 11383 | + ExpressionFastTranslate(ae,&ae->wl[ae->idx+2].w,0); | |
| 11384 | + myvalue=RoundComputeExpression(ae,ae->wl[ae->idx+2].w,ae->codeadr,0,0); | |
| 11385 | + | |
| 11386 | + if (strcmp(ae->wl[ae->idx].w,"GA_PAL")==0) { | |
| 11387 | + if (idx>=0 && idx<17) { | |
| 11388 | + ae->snapshot.gatearray.palette[idx]=myvalue; | |
| 11389 | + } else { | |
| 11390 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive needs [0-16] index for GA_PAL\n"); | |
| 11391 | + } | |
| 11392 | + } else if (strcmp(ae->wl[ae->idx].w,"CRTC_REG")==0) { | |
| 11393 | + if (idx>=0 && idx<18) { | |
| 11394 | + ae->snapshot.crtc.registervalue[idx]=myvalue; | |
| 11395 | + } else { | |
| 11396 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive needs [0-17] index for CRTC_REG\n"); | |
| 11397 | + } | |
| 11398 | + } else if (strcmp(ae->wl[ae->idx].w,"PSG_REG")==0) { | |
| 11399 | + if (idx>=0 && idx<16) { | |
| 11400 | + ae->snapshot.psg.registervalue[idx]=myvalue; | |
| 11401 | + } else { | |
| 11402 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive needs [0-15] index for PSG_REG\n"); | |
| 11403 | + } | |
| 11404 | + } else { | |
| 11405 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive unknown array settings\n"); | |
| 11406 | + } | |
| 11407 | + } else { | |
| 11408 | + MakeError(ae,GetCurrentFile(ae),ae->wl[ae->idx].l,"SNASET directive need 2 or 3 parameters (see documentation for more informations)\n"); | |
| 11409 | + } | |
| 11410 | + } | |
| 11411 | + | |
| 11412 | + | |
| 11413 | +} | |
| 11414 | + | |
| 11415 | + | |
| 11096 | 11416 | void __SETCPC(struct s_assenv *ae) { |
| 11097 | 11417 | int mycpc; |
| 11098 | 11418 | |
| 11419 | + rasm_printf(ae,KWARNING"[%s:%d] Warning: SETCPC is deprecated, use SNASET CPC_TYPE,<type> instead\n",GetCurrentFile(ae),ae->wl[ae->idx].l); | |
| 11420 | + | |
| 11099 | 11421 | if (!ae->forcecpr) { |
| 11100 | 11422 | ae->forcesnapshot=1; |
| 11101 | 11423 | } else { |
| @@ -11128,6 +11450,8 @@ void __SETCPC(struct s_assenv *ae) { · 26 unmodified lines | ||
| 11128 | 11450 | void __SETCRTC(struct s_assenv *ae) { |
| 11129 | 11451 | int mycrtc; |
| 11130 | 11452 | |
| 11453 | + rasm_printf(ae,KWARNING"[%s:%d] Warning: SETCRTC is deprecated, use SNASET CRTC_TYPE,<type> instead\n",GetCurrentFile(ae),ae->wl[ae->idx].l); | |
| 11454 | + | |
| 11131 | 11455 | if (!ae->forcecpr) { |
| 11132 | 11456 | ae->forcesnapshot=1; |
| 11133 | 11457 | } else { |
| @@ -13605,6 +13929,7 @@ struct s_asm_keyword instruction[]={ · 2471 unmodified lines | ||
| 13605 | 13929 | {"LZ48",0,__LZ48}, |
| 13606 | 13930 | {"LZ49",0,__LZ49}, |
| 13607 | 13931 | {"LZCLOSE",0,__LZCLOSE}, |
| 13932 | +{"SNASET",0,__SNASET}, | |
| 13608 | 13933 | {"BUILDZX",0,__BUILDZX}, |
| 13609 | 13934 | {"BUILDCPR",0,__BUILDCPR}, |
| 13610 | 13935 | {"BUILDSNA",0,__BUILDSNA}, |
| @@ -13706,6 +14031,7 @@ printf("*** assembling ***\n"); · 95 unmodified lines | ||
| 13706 | 14031 | /* set operator precedence */ |
| 13707 | 14032 | if (!ae->maxam) { |
| 13708 | 14033 | for (i=0;i<256;i++) { |
| 14034 | + ae->AutomateElement[i].string=NULL; | |
| 13709 | 14035 | switch (i) { |
| 13710 | 14036 | /* priority 0 */ |
| 13711 | 14037 | case '(':ae->AutomateElement[i].operator=E_COMPUTE_OPERATION_OPEN;ae->AutomateElement[i].priority=0;break; |
| @@ -13744,6 +14070,7 @@ printf("*** assembling ***\n"); · 32 unmodified lines | ||
| 13744 | 14070 | } |
| 13745 | 14071 | } else { |
| 13746 | 14072 | for (i=0;i<256;i++) { |
| 14073 | + ae->AutomateElement[i].string=NULL; | |
| 13747 | 14074 | switch (i) { |
| 13748 | 14075 | /* priority 0 */ |
| 13749 | 14076 | case '(':ae->AutomateElement[i].operator=E_COMPUTE_OPERATION_OPEN;ae->AutomateElement[i].priority=0;break; |
| @@ -15462,12 +15789,9 @@ printf("start prepro, alloc assenv\n"); · 1712 unmodified lines | ||
| 15462 | 15789 | rindex.cidx=-1; |
| 15463 | 15790 | |
| 15464 | 15791 | #if TRACE_PREPRO |
| 15465 | −printf("malloc\n"); | |
| 15792 | +printf("malloc+memset\n"); | |
| 15466 | 15793 | #endif |
| 15467 | 15794 | ae=MemMalloc(sizeof(struct s_assenv)); |
| 15468 | −#if TRACE_PREPRO | |
| 15469 | −printf("memset\n"); | |
| 15470 | −#endif | |
| 15471 | 15795 | memset(ae,0,sizeof(struct s_assenv)); |
| 15472 | 15796 | |
| 15473 | 15797 | #if TRACE_PREPRO |
| @@ -17184,6 +17508,30 @@ int RasmAssembleInfo(const char *datain, int lenin, unsigned char **dataout, int · 1710 unmodified lines | ||
| 17184 | 17508 | #define AUTOTEST_MODULE02 "unglobal: nop: .prox: nop: module un: deuxglobal: nop: .prox: nop: djnz .prox: nop: doublon: nop: module deux: troisglobal: nop: " \ |
| 17185 | 17509 | " .prox: nop: djnz .prox: nop: doublon: nop: assert doublon>troisglobal: module: jr un_doublon: jr deux_doublon: jr un_deuxglobal.prox: jr deux_troisglobal.prox " |
| 17186 | 17510 | |
| 17511 | +#define AUTOTEST_SNASET "buildsna:bank 0:nop:"\ | |
| 17512 | + ":snaset Z80_AF,0x1234 :snaset Z80_A,0x11 :snaset Z80_F,0x11 :snaset Z80_BC,0x11 :snaset Z80_B,0x11 :snaset Z80_C,0x11 :snaset Z80_DE,0x11 :snaset Z80_D,0x11"\ | |
| 17513 | + ":snaset Z80_E,0x11 :snaset Z80_HL,0x11 :snaset Z80_H,0x11 :snaset Z80_L,0x11 :snaset Z80_R,0x11 :snaset Z80_I,0x11 :snaset Z80_IFF0,0x11 :snaset Z80_IFF1,0x11"\ | |
| 17514 | + ":snaset Z80_IX,0x11 :snaset Z80_IY,0x11 :snaset Z80_IXL,0x11 :snaset Z80_IXH,0x11 :snaset Z80_IYL,0x11 :snaset Z80_IYH,0x11 :snaset Z80_SP,0x11 :snaset Z80_PC,0x11"\ | |
| 17515 | + ":snaset Z80_IM,0x11 :snaset Z80_AFX,0x11 :snaset Z80_AX,0x11 :snaset Z80_FX,0x11 :snaset Z80_BCX,0x11 :snaset Z80_BX,0x11 :snaset Z80_CX,0x11 :snaset Z80_DEX,0x11"\ | |
| 17516 | + ":snaset Z80_DX,0x11 :snaset Z80_EX,0x11 :snaset Z80_HLX,0x11 :snaset Z80_HX,0x11 :snaset Z80_LX,0x11 :snaset FDD_MOTOR,0x11 :snaset FDD_TRACK,0x11 :snaset PRNT_DATA,0x11"\ | |
| 17517 | + ":snaset PPI_A,0x1 :snaset PPI_B,0x1 :snaset PPI_C,0x1 :snaset PPI_CTL,0x1 :snaset INT_NUM,0x1 :snaset INT_REQ,0x11 :snaset PSG_SEL,0x1 :snaset CRTC_SEL,0x1"\ | |
| 17518 | + ":snaset CRTC_TYPE,0x1 :snaset CRTC_HCC,0x11 :snaset CRTC_CLC,0x11 :snaset CRTC_RLC,0x11 :snaset CRTC_VAC,0x11 :snaset CRTC_VSWC,0x11 :snaset CRTC_HSWC,0x11"\ | |
| 17519 | + ":snaset CRTC_STATE,0x11 :snaset GA_VSC,0x11 :snaset GA_ISC,0x11 :snaset GA_PEN,0x11 :snaset GA_ROMCFG,0x11 :snaset GA_RAMCFG,0x11 :snaset ROM_UP,0x11"\ | |
| 17520 | + ":snaset CRTC_REG,0,0x11 :snaset CRTC_REG,1,0x11 :snaset CRTC_REG,16,0x11 :snaset PSG_REG,0,0x11 :snaset PSG_REG,5,0x11 :snaset PSG_REG,15,0x11: bank : nop" | |
| 17521 | + | |
| 17522 | +#define AUTOTEST_INKCONV "assert s2h_ink(0)==0x54 :assert s2h_ink(1)==0x44 :assert s2h_ink(2)==0x55 :assert s2h_ink(3)==0x5C :assert s2h_ink(4)==0x58 :assert s2h_ink(5)==0x5D "\ | |
| 17523 | +":assert s2h_ink(6)==0x4C :assert s2h_ink(7)==0x45 :assert s2h_ink(8)==0x4D :assert s2h_ink(9)==0x56 :assert s2h_ink(10)==0x46 :assert s2h_ink(11)==0x57 "\ | |
| 17524 | +":assert s2h_ink(12)==0x5E :assert s2h_ink(13)==0x40 :assert soft2hard_ink(14)==0x5F :assert soft2hard_ink(15)==0x4E :assert soft2hard_ink(16)==0x47 "\ | |
| 17525 | +":assert soft2hard_ink(17)==0x4F :assert soft2hard_ink(18)==0x52 :assert soft2hard_ink(19)==0x42 :assert soft2hard_ink(20)==0x53 :assert soft2hard_ink(21)==0x5A "\ | |
| 17526 | +":assert soft2hard_ink(22)==0x59 :assert soft2hard_ink(23)==0x5B :assert soft2hard_ink(24)==0x4A :assert soft2hard_ink(25)==0x43 :assert soft2hard_ink(26)==0x4B "\ | |
| 17527 | +":nop :assert h2s_ink(0)==13 :assert h2s_ink(0x40)==13 :assert h2s_ink(1)==13 :assert h2s_ink(2)==19 :assert h2s_ink(3)==25 :assert h2s_ink(4)==1 "\ | |
| 17528 | +":assert h2s_ink(5)==7 :assert h2s_ink(6)==10 :assert h2s_ink(7)==16 :assert h2s_ink(8)==7 :assert h2s_ink(9)==25 :assert h2s_ink(10)==24 "\ | |
| 17529 | +":assert h2s_ink(11)==26 :assert h2s_ink(12)==6 :assert h2s_ink(13)==8 :assert h2s_ink(14)==15 :assert hard2soft_ink(15)==17 :assert hard2soft_ink(16)==1 "\ | |
| 17530 | +":assert hard2soft_ink(17)==19 :assert hard2soft_ink(18)==18 :assert hard2soft_ink(19)==20 :assert hard2soft_ink(20)==0 :assert hard2soft_ink(21)==2 "\ | |
| 17531 | +":assert hard2soft_ink(22)==9 :assert hard2soft_ink(23)==11 :assert hard2soft_ink(24)==4 :assert hard2soft_ink(25)==22 :assert hard2soft_ink(26)==21 "\ | |
| 17532 | +":assert hard2soft_ink(27)==23 :assert hard2soft_ink(28)==3 :assert hard2soft_ink(29)==5 :assert h2s_ink(30)==12 :assert h2s_ink(31)==14 :nop " | |
| 17533 | + | |
| 17534 | + | |
| 17187 | 17535 | |
| 17188 | 17536 | struct s_autotest_keyword { |
| 17189 | 17537 | char *keywordtest; |
| @@ -17266,7 +17614,22 @@ struct s_autotest_keyword autotest_keyword[]={ · 76 unmodified lines | ||
| 17266 | 17614 | {"repeat 5:nop:rend",0},{"repeat 100000:a=5:rend",1},{"repeat -5:nop:rend",1},{"repeat repeat:nop:rend",1}, |
| 17267 | 17615 | {"macro bidule:nop:mend:bidule",0},{"macro bidule:nop:macro glop:nop:mend:mend:bidule",1}, |
| 17268 | 17616 | {"macro bidule:nop",1},{"macro bidule:nop:mend:macro glop:nop:bidule",1}, |
| 17617 | + {"defb getnop(1)",1},{"defb getnop(-1)",1},{"defb getnop(10)",1},{"defb getnop(\"rien\")",1},{"defb getnop()",1},{"defb getnop(\"djNz\")",0}, | |
| 17618 | + /* wrong snapshot settings */ | |
| 17619 | + {"buildsna:bank 0:nop:snaset crtc_type",1}, | |
| 17620 | + {"buildsna:bank 0:nop:snaset crtc_type,3,2",1}, | |
| 17621 | + {"buildsna:bank 0:nop:snaset crtc_reg,3",1}, | |
| 17622 | + {"buildsna:bank 0:nop:snaset crtc_reg,20,0",1}, | |
| 17623 | + {"buildsna:bank 0:nop:snaset crtc_reg,-1,0",1}, | |
| 17624 | + {"buildsna:bank 0:nop:snaset psg_reg,3",1}, | |
| 17625 | + {"buildsna:bank 0:nop:snaset psg_reg,20,0",1}, | |
| 17626 | + {"buildsna:bank 0:nop:snaset psg_reg,-1,0",1}, | |
| 17627 | + {"buildsna:bank 0:nop:snaset ga_pal,3",1}, | |
| 17628 | + {"buildsna:bank 0:nop:snaset ga_pal,20,0",1}, | |
| 17629 | + {"buildsna:bank 0:nop:snaset ga_pal,-1,0",1}, | |
| 17269 | 17630 | /* |
| 17631 | + {"",},{"",},{"",},{"",},{"",}, | |
| 17632 | + {"",},{"",},{"",},{"",},{"",},{"",}, | |
| 17270 | 17633 | {"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",}, |
| 17271 | 17634 | {"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",}, |
| 17272 | 17635 | {"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",},{"",}, |
| @@ -17896,6 +18259,16 @@ printf("testing enhanced LD variante OK\n"); · 623 unmodified lines | ||
| 17896 | 18259 | if (opcode) MemFree(opcode);opcode=NULL;cpt++; |
| 17897 | 18260 | printf("testing enhanced PUSH/POP OK\n"); |
| 17898 | 18261 | |
| 18262 | + ret=RasmAssembleInfo(AUTOTEST_INKCONV,strlen(AUTOTEST_INKCONV),&opcode,&opcodelen,&debug); | |
| 18263 | + if (!ret && opcodelen==2) {} else {printf("Autotest %03d ERROR (gate array color conversion)\n",cpt);MiniDump(opcode,opcodelen);for (i=0;i<debug->nberror;i++) printf("%d -> %s\n",i,debug->error[i].msg);exit(-1);} | |
| 18264 | + if (opcode) MemFree(opcode);opcode=NULL;cpt++; | |
| 18265 | +printf("testing gate array color conversion OK\n"); | |
| 18266 | + | |
| 18267 | + ret=RasmAssembleInfo(AUTOTEST_SNASET,strlen(AUTOTEST_SNASET),&opcode,&opcodelen,&debug); | |
| 18268 | + if (!ret) {} else {printf("Autotest %03d ERROR (snapshot settings)\n",cpt);MiniDump(opcode,opcodelen);for (i=0;i<debug->nberror;i++) printf("%d -> %s\n",i,debug->error[i].msg);exit(-1);} | |
| 18269 | + if (opcode) MemFree(opcode);opcode=NULL;cpt++; | |
| 18270 | +printf("testing snapshot settings OK\n"); | |
| 18271 | + | |
| 17899 | 18272 | ret=RasmAssemble(AUTOTEST_PAGELABELGEN,strlen(AUTOTEST_PAGELABELGEN),&opcode,&opcodelen); |
| 17900 | 18273 | if (!ret) {} else {printf("Autotest %03d ERROR (pagelabelgen)\n",cpt);MiniDump(opcode,opcodelen);exit(-1);} |
| 17901 | 18274 | if (opcode) MemFree(opcode);opcode=NULL;cpt++; |