core.c

AUTOMGEN runtime is an open source royalty free runtime for open PLCs. By using this runtime, any ta

// AUTOMGEN interpretor runtime	 - core
// (C) 2003-2008 IRAI

#include "memory.h"
#include "stdlib.h"
#include "math.h"

#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned long

#include "target.h"
#include "core.h"
#include "com.h"


// Internal boolean tables
unsigned char *booltable1[BOOLTABLELEN];
unsigned booltable1len=0;
unsigned char *booltable2[BOOLTABLELEN];
unsigned booltable2len=0;
char boolvarselector;
// Sub routines calls stack
unsigned char *srstack[SRSTACKLEN];
unsigned srstackpos=0;


// Set a boolean varariable state
void setvar(struct _a7int *a7int,unsigned type,unsigned num,int state,unsigned pos)
{
unsigned char *pVar,**pVar2;
unsigned count;
#ifndef NOFORCE
if(pos==(unsigned)-1)
	{ // System request
	if(state>=3&&state<=5)
		{
		int force;
		switch(state)
			{
			case 3 : force=1; break;
			case 4 : force=0; break;
			case 5 : force=2; break;
			}
		setforce(a7int,(BYTE)type,(WORD)num,force);
		return;
		}
	}
#endif
switch(type)
	{
	case 0 : pVar=&a7int->pI[num]; break;
	case 1 : pVar=&a7int->pO[num]; break;
	case 2 : pVar=&a7int->pB[num]; break;
	case 3 : pVar=&a7int->pT[(2*sizeof(unsigned long)*a7int->nt)+num]; break;
	case 4 :
		{
		unsigned short *pWord;
		pWord=&a7int->pC[num]; 
		switch(state)
			{
			case 0 : *pWord=0; break;
			case 1 : *pWord=0xffff; break;
			case 2 : *pWord^=0xffff; break;
			}
		return;
		} 
	case 5 :
		{
		unsigned short *pWord;
		pWord=&a7int->pM[num]; 
		switch(state)
			{
			case 0 : *pWord=0; break;
			case 1 : *pWord=0xffff; break;
			case 2 : *pWord^=0xffff; break;
			}
		return;
		} 
	case 7 :
		{
		unsigned long *pDWord;
		pDWord=&a7int->pL[num]; 
		switch(state)
			{
			case 0 : *pDWord=0; break;
			case 1 : *pDWord=0xffffffff; break;
			case 2 : *pDWord^=0xffffffff; break;
			}
		return;
		} 
	default : 
		{
		#ifdef _SECURE
		a7int->pB[SYSTEM_BIT_FAULT]=TRUEFORBOOL; 
		a7int->pB[SYSTEM_BIT_EMERGENCY_STOP]=TRUEFORBOOL; 
		a7int->pL[SYSTEM_WORD_ERROR_POSITION]=pos;
		a7int->pM[SYSTEM_WORD_ERROR_NUMBER]=AUTOMGEN_ERR_ILLEGALACTIONBOOLVAR;
		target_fatal();
		#endif
		return;
		}
	}
switch(state)
	{
	case 0 : // reset
		{
		if(!(*pVar&0x10)) return; // Already false
		*pVar&=~0x10;
		} break;
	case 1 : // set
		{
		if(*pVar&0x10) return; // Already true
		*pVar|=0x10;
		} break;
	case 2 : // Inversion
		{
		*pVar^=0x10;
		} break;
	default :
		{
		#ifdef _SECURE
		a7int->pB[SYSTEM_BIT_FAULT]=TRUEFORBOOL;  
		a7int->pB[SYSTEM_BIT_EMERGENCY_STOP]=TRUEFORBOOL; 
		a7int->pL[SYSTEM_WORD_ERROR_POSITION]=pos;
		a7int->pM[SYSTEM_WORD_ERROR_NUMBER]=AUTOMGEN_ERR_ILLEGALACTIONBOOLSET;
		target_fatal();
		#endif
		return;
		}
	}
// If already in table #2, remove frome table #2
if(!boolvarselector)
	{
	pVar2=booltable2;
	for(count=0;count<booltable2len;count++)
		{
		if(pVar==*pVar2)
			{
			*pVar2=(unsigned char *)(void *)-1; // Cancel this item
			break;
			}
		pVar2++;	
		}
	// Add item to table #1
	if(booltable1len==BOOLTABLELEN)
		{
		a7int->pB[SYSTEM_BIT_INTERNAL_TABLE_OVERFLOW]=TRUEFORBOOL;  // Table overflow
		a7int->pB[SYSTEM_BIT_EMERGENCY_STOP]=TRUEFORBOOL; 
		a7int->pL[SYSTEM_WORD_ERROR_POSITION]=pos;
		a7int->pM[SYSTEM_WORD_ERROR_NUMBER]=AUTOMGEN_ERR_BOOLTABLEFULL;
		target_fatal();
		return;
		}
	booltable1[booltable1len++]=pVar;
	}
else
	{
	pVar2=booltable1;
	for(count=0;count<booltable1len;count++)
		{
		if(pVar==*pVar2)
			{
			*pVar2=(unsigned char *)(void *)-1; // Cancel this item
			break;
			}
		pVar2++;	
		}
	// Add item to table #1
	if(booltable2len==BOOLTABLELEN)
		{
		// Table overflow
		a7int->pB[SYSTEM_BIT_INTERNAL_TABLE_OVERFLOW]=TRUEFORBOOL;  
		a7int->pB[SYSTEM_BIT_EMERGENCY_STOP]=TRUEFORBOOL; 
		a7int->pL[SYSTEM_WORD_ERROR_POSITION]=pos;
		a7int->pM[SYSTEM_WORD_ERROR_NUMBER]=AUTOMGEN_ERR_BOOLTABLEFULL;
		target_fatal();
		return;
		}
	booltable2[booltable2len++]=pVar;
	}
}

#ifndef NOFORCE




// Process forcing
void processforce(struct _a7int *a7int)
{
// BIT #39            :     FORCING ENABLE
// BITS #40 to 55     :     FORCING STATE
// LES MOTS 146