jbimain.c

microwindows移植到S3C44B0的源码

				stack[stack_ptr - 1] =
					(stack[stack_ptr - 1] == stack[stack_ptr]) ? 1L : 0L;
			}
			break;

		case 0x27: /* POPT  */
			IF_CHECK_STACK(1)
			{
				--stack_ptr;
			}
			break;

		case 0x28: /* TRST  */
			bad_opcode = 1;
			break;

		case 0x29: /* FRQ   */
			bad_opcode = 1;
			break;

		case 0x2A: /* FRQU  */
			bad_opcode = 1;
			break;

		case 0x2B: /* PD32  */
			bad_opcode = 1;
			break;

		case 0x2C: /* ABS   */
			IF_CHECK_STACK(1)
			{
				if (stack[stack_ptr - 1] < 0)
				{
					stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1];
				}
			}
			break;

		case 0x2D: /* BCH0  */
			/*
			*	Batch operation 0
			*	SWP
			*	SWPN 7
			*	SWP
			*	SWPN 6
			*	DUPN 8
			*	SWPN 2
			*	SWP
			*	DUPN 6
			*	DUPN 6
			*/

			/* SWP  */
			IF_CHECK_STACK(2)
			{
				long_temp = stack[stack_ptr - 2];
				stack[stack_ptr - 2] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* SWPN 7 */
			index = 7 + 1;
			IF_CHECK_STACK(index)
			{
				long_temp = stack[stack_ptr - index];
				stack[stack_ptr - index] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* SWP  */
			IF_CHECK_STACK(2)
			{
				long_temp = stack[stack_ptr - 2];
				stack[stack_ptr - 2] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* SWPN 6 */
			index = 6 + 1;
			IF_CHECK_STACK(index)
			{
				long_temp = stack[stack_ptr - index];
				stack[stack_ptr - index] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* DUPN 8 */
			index = 8 + 1;
			IF_CHECK_STACK(index)
			{
				stack[stack_ptr] = stack[stack_ptr - index];
				++stack_ptr;
			}

			/* SWPN 2 */
			index = 2 + 1;
			IF_CHECK_STACK(index)
			{
				long_temp = stack[stack_ptr - index];
				stack[stack_ptr - index] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* SWP  */
			IF_CHECK_STACK(2)
			{
				long_temp = stack[stack_ptr - 2];
				stack[stack_ptr - 2] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}

			/* DUPN 6 */
			index = 6 + 1;
			IF_CHECK_STACK(index)
			{
				stack[stack_ptr] = stack[stack_ptr - index];
				++stack_ptr;
			}

			/* DUPN 6 */
			index = 6 + 1;
			IF_CHECK_STACK(index)
			{
				stack[stack_ptr] = stack[stack_ptr - index];
				++stack_ptr;
			}
			break;

		case 0x2E: /* BCH1  */
			/*
			*	Batch operation 1
			*	SWPN 8
			*	SWP
			*	SWPN 9
			*	SWPN 3
			*	SWP
			*	SWPN 2
			*	SWP
			*	SWPN 7
			*	SWP
			*	SWPN 6
			*	DUPN 5
			*	DUPN 5
			*/
			bad_opcode = 1;
			break;

		case 0x2F: /* PSH0  */
			stack[stack_ptr++] = 0;
			break;

		case 0x40: /* PSHL */
			stack[stack_ptr++] = (long) args[0];
			break;

		case 0x41: /* PSHV */
			stack[stack_ptr++] = variables[args[0]];
			break;

		case 0x42: /* JMP  */
			pc = args[0] + code_section;
			CHECK_PC;
			break;

		case 0x43: /* CALL */
			stack[stack_ptr++] = pc;
			pc = args[0] + code_section;
			CHECK_PC;
			break;

		case 0x44: /* NEXT */
			/*
			*	Process FOR / NEXT loop
			*	...argument 0 is variable ID
			*	...stack 0 is step value
			*	...stack 1 is end value
			*	...stack 2 is top address
			*/
			IF_CHECK_STACK(3)
			{
				long step = stack[stack_ptr - 1];
				long end = stack[stack_ptr - 2];
				long top = stack[stack_ptr - 3];
				long iterator = variables[args[0]];
				int break_out = 0;

				if (step < 0)
				{
					if (iterator <= end) break_out = 1;
				}
				else
				{
					if (iterator >= end) break_out = 1;
				}

				if (break_out)
				{
					stack_ptr -= 3;
				}
				else
				{
					variables[args[0]] = iterator + step;
					pc = top + code_section;
					CHECK_PC;
				}
			}
			break;

		case 0x45: /* PSTR */
			/*
			*	PRINT add string
			*	...argument 0 is string ID
			*/
#if PORT==DOS
			long_index = string_table + args[0];
			index2 = jbi_strlen(message_buffer);

			do
			{
				i = GET_BYTE(long_index);
				message_buffer[index2] = (char) i;
				++long_index;
				++index2;
			}
			while ((i != '\0') && (index2 < JBIC_MESSAGE_LENGTH));
#else
			count = jbi_strlen(message_buffer);
			jbi_strncpy(&message_buffer[count],
				(char *) &program[string_table + args[0]],
				JBIC_MESSAGE_LENGTH - count);
#endif
			message_buffer[JBIC_MESSAGE_LENGTH] = '\0';
			break;

		case 0x46: /* VMAP */
			/*
			*	VMAP add signal name
			*	...argument 0 is string ID
			*/
			bad_opcode = 1;
			break;

		case 0x47: /* SINT */
			/*
			*	STATE intermediate state
			*	...argument 0 is state code
			*/
			status = jbi_goto_jtag_state((int) args[0]);
			break;

		case 0x48: /* ST   */
			/*
			*	STATE final state
			*	...argument 0 is state code
			*/
			status = jbi_goto_jtag_state((int) args[0]);
			break;

		case 0x49: /* ISTP */
			/*
			*	IRSTOP state
			*	...argument 0 is state code
			*/
			status = jbi_set_irstop_state((int) args[0]);
			break;

		case 0x4A: /* DSTP */
			/*
			*	DRSTOP state
			*	...argument 0 is state code
			*/
			status = jbi_set_drstop_state((int) args[0]);
			break;

		case 0x4B: /* SWPN */
			/*
			*	Exchange top with Nth stack value
			*	...argument 0 is 0-based stack entry to swap with top element
			*/
			index = ((int) args[0]) + 1;
			IF_CHECK_STACK(index)
			{
				long_temp = stack[stack_ptr - index];
				stack[stack_ptr - index] = stack[stack_ptr - 1];
				stack[stack_ptr - 1] = long_temp;
			}
			break;

		case 0x4C: /* DUPN */
			/*
			*	Duplicate Nth stack value
			*	...argument 0 is 0-based stack entry to duplicate
			*/
			index = ((int) args[0]) + 1;
			IF_CHECK_STACK(index)
			{
				stack[stack_ptr] = stack[stack_ptr - index];
				++stack_ptr;
			}
			break;

		case 0x4D: /* POPV */
			/*
			*	Pop stack into scalar variable
			*	...argument 0 is variable ID
			*	...stack 0 is value
			*/
			IF_CHECK_STACK(1)
			{
				variables[args[0]] = stack[--stack_ptr];
			}
			break;

		case 0x4E: /* POPE */
			/*
			*	Pop stack into integer array element
			*	...argument 0 is variable ID
			*	...stack 0 is array index
			*	...stack 1 is value
			*/
			IF_CHECK_STACK(2)
			{
				variable_id = (unsigned int) args[0];

				/*
				*	If variable is read-only, convert to writable array
				*/
				if ((version > 0) &&
					((attributes[variable_id] & 0x9c) == 0x1c))
				{
					/*
					*	Allocate a writable buffer for this array
					*/
					count = (unsigned int) variable_size[variable_id];
					long_temp = variables[variable_id];
					longptr_temp = (long *) jbi_malloc(count * sizeof(long));
					variables[variable_id] = (long) longptr_temp;

					if (variables[variable_id] == NULL)
					{
						status = JBIC_OUT_OF_MEMORY;
						break;
					}
					else
					{
						/* copy previous contents into buffer */
						for (i = 0; i < count; ++i)
						{
							longptr_temp[i] = GET_DWORD(long_temp);
							long_temp += 4L;
						}

						/* set bit 7 - buffer was dynamically allocated */
						attributes[variable_id] |= 0x80;

						/* clear bit 2 - variable is writable */
						attributes[variable_id] &= ~0x04;
						attributes[variable_id] |= 0x01;
					}
				}

#if PORT==DOS
				/* for 16-bit version, allow writing in allocated buffers */
				if ((version > 0) &&
					((attributes[variable_id] & 0x9c) == 0x9c))
				{
					attributes[variable_id] &= ~0x04;
					attributes[variable_id] |= 0x01;
				}
#endif

				/* check that variable is a writable integer array */
				if ((attributes[variable_id] & 0x1c) != 0x18)
				{
					status = JBIC_BOUNDS_ERROR;
				}
				else
				{
					longptr_temp = (long *) variables[variable_id];

					/* pop the array index */
					index = (unsigned int) stack[--stack_ptr];

					/* pop the value and store it into the array */
					longptr_temp[index] = stack[--stack_ptr];
				}
			}
			break;

		case 0x4F: /* POPA */
			/*
			*	Pop stack into Boolean array
			*	...argument 0 is variable ID
			*	...stack 0 is count
			*	...stack 1 is array index
			*	...stack 2 is value
			*/
			IF_CHECK_STACK(3)
			{
				variable_id = (unsigned int) args[0];

				/*
				*	If variable is read-only, convert to writable array
				*/
				if ((version > 0) &&
					((attributes[variable_id] & 0x9c) == 0x0c))
				{
					/*
					*	Allocate a writable buffer for this array
					*/
					long_temp = (variable_size[variable_id] + 7L) >> 3L;
					charptr_temp2 = (unsigned char *) variables[variable_id];
					charptr_temp = jbi_malloc((unsigned int) long_temp);
					variables[variable_id] = (long) charptr_temp;

					if (variables[variable_id] == NULL)
					{
						status = JBIC_OUT_OF_MEMORY;
					}
					else
					{
						/* zero the buffer */
						for (long_index = 0L;
							long_index < long_temp;
							++long_index)
						{
							charptr_temp[long_index] = 0;
						}

						/* copy previous contents into buffer */
						for (long_index = 0L;
							long_index < variable_size[variable_id];
							++long_index)
						{
#if PORT==DOS
							if ((attributes[variable_id] & 0x02) &&
								(long_index & 0xFFFF == 0))
							{
								/* initialized compressed Boolean array */
								jbi_uncompress_page(variable_id,
									(int) (long_index >> 16), version);
								charptr_temp = jbi_aca_out_buffer;
								long_index2 = long_index & 0xFFFF;
							}
#else
							long_index2 = long_index;
#endif

							if (charptr_temp2[long_index2 >> 3] &
								(1 << (long_index2 & 7)))
							{
								charptr_temp[long_index >> 3] |=
									(1 << (long_index & 7));
							}
						}

						/* set bit 7 - buffer was dynamically allocated */
						attributes[variable_id] |= 0x80;

						/* clear bit 2 - variable is writable */
						attributes[variable_id] &= ~0x04;
						attributes[variable_id] |= 0x01;
					}
				}

#if PORT==DOS
				/* for 16-bit version, allow writing in allocated buffers */
				if ((version > 0) &&
					((attributes[variable_id] & 0x9c) == 0x8c))
				{
					attributes[variable_id] &= ~0x04;
					attributes[variable_id] |= 0x01;
				}
#endif

				/* check that variable is a writable Boolean array */
				if ((attributes[variable_id] & 0x1c) != 0x08)
				{
					status = JBIC_BOUNDS_ERROR;
				}
				else
				{
					charptr_temp = (unsigned char *) variables[variable_id];

					/* pop the count (number of bits to copy) */
					long_count = stack[--stack_ptr];

					/* pop the array index */
					long_index = stack[--stack_ptr];

					reverse = 0;

					if (version > 0)
					{
						/* stack 0 = array right index */
						/* stack 1 = array left index */

						if (long_index > long_count)
						{
							reverse = 1;
							long_temp = long_count;
							long_count = 1 + long_index - long_count;
							long_index = long_temp;

							/* reverse POPA is not supported */
							status = JBIC_BOUNDS_ERROR;
							break;
						}
						else
						{
							long_count = 1 + long_count - long_index;
						}
					}

					/* pop the data */
					long_temp = stack[--stack_ptr];

					if (long_count < 1)
					{
						status = JBIC_BOUNDS_ERROR;
					}
					else
					{
						for (i = 0; i < (unsigned int) long_count; ++i)
						{
							if (long_temp & (1L << (long) i))
							{
								charptr_temp[long_index >> 3L] |=
									(1L << (long_index & 7L));
							}
							else
							{
								charptr_temp[long_index >> 3L] &=
									~ (unsigned int) (1L << (long_index & 7L));
							}
							++long_index;
						}
					}
				}
			}
			break;

		case 0x50: /* JMPZ */
			/*
			*	Pop stack and branch if zero
			*	...argument 0 is address
			*	...stack 0 is condition value
			*/
			IF_CHECK_STACK(1)
			{
				if (stack[--stack_ptr] == 0)
				{
					pc = args[0] + code_section;
					CHECK_PC;
				}
			}
			break;

		case 0x51: /* DS   */
		case 0x52: /* IS   */
			/*
			*	DRSCAN
			*	IRSCAN
			*	...argument 0 is scan data variable ID
			*	...stack 0 is array index
			*	...stack 1 is count
			*/