/*
* シリアルポートからの1文字受信
*/
static bool_t
serialPort_readChar(CELLCB *p_cellcb, char *p_c)
{
bool_t buffer_empty;
ER ercd;
SVC(loc_cpu(), gen_ercd_sys(p_cellcb));
/*
* 受信バッファから文字を取り出す．
*/
*p_c = VAR_receiveBuffer[VAR_receiveReadPointer];
INC_PTR(VAR_receiveReadPointer, ATTR_receiveBufferSize);
VAR_receiveCount--;
buffer_empty = (VAR_receiveCount == 0U);
/*
* STARTを送信する．
*/
if (VAR_receiveStopped && VAR_receiveCount
<= BUFCNT_START(ATTR_receiveBufferSize)) {
if (!serialPort_sendChar(p_cellcb, FC_START)) {
VAR_receiveFlowControl = FC_START;
}
VAR_receiveStopped = false;
}
SVC(unl_cpu(), gen_ercd_sys(p_cellcb));
ercd = (ER_BOOL) buffer_empty;
error_exit:
return(ercd);
}
/*
* シリアルポートからの1文字受信
*/
static bool_t
serial_rea_chr(SPCB *p_spcb, char *p_c)
{
bool_t buffer_empty;
ER ercd;
SVC(loc_cpu(), gen_ercd_sys(p_spcb));
/*
* 受信バッファから文字を取り出す．
*/
*p_c = p_spcb->p_spinib->rcv_buffer[p_spcb->rcv_read_ptr];
INC_PTR(p_spcb->rcv_read_ptr, p_spcb->p_spinib->rcv_bufsz);
p_spcb->rcv_count--;
buffer_empty = (p_spcb->rcv_count == 0U);
/*
* STARTを送信する．
*/
if (p_spcb->rcv_stopped && p_spcb->rcv_count
<= BUFCNT_START(p_spcb->p_spinib->rcv_bufsz)) {
if (!serial_snd_chr(p_spcb, FC_START)) {
p_spcb->rcv_fc_chr = FC_START;
}
p_spcb->rcv_stopped = false;
}
SVC(unl_cpu(), gen_ercd_sys(p_spcb));
ercd = (ER_BOOL) buffer_empty;
error_exit:
return(ercd);
}
/*
* シリアルポートのクローズ（サービスコール）
*/
ER
serial_cls_por(ID portid)
{
SPCB *p_spcb;
ER ercd;
bool_t eflag = false;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
p_spcb = get_spcb(portid);
SVC(dis_dsp(), gen_ercd_sys(p_spcb));
if (!(p_spcb->openflag)) { /* オープン済みかのチェック */
ercd = E_OBJ;
}
else {
/*
* ハードウェア依存のクローズ処理
*/
if (loc_cpu() < 0) {
eflag = true;
}
sio_cls_por(p_spcb->p_siopcb);
p_spcb->openflag = false;
if (unl_cpu() < 0) {
eflag = true;
}
/*
* セマフォの初期化
*/
if (ini_sem(p_spcb->p_spinib->snd_semid) < 0) {
eflag = true;
}
if (ini_sem(p_spcb->p_spinib->rcv_semid) < 0) {
eflag = true;
}
/*
* エラーコードの設定
*/
if (eflag) {
ercd = gen_ercd_sys(p_spcb);
}
else {
ercd = E_OK;
}
}
SVC(ena_dsp(), gen_ercd_sys(p_spcb));
error_exit:
return(ercd);
}
/*
* シリアルポートのクローズ（受け口関数）
*/
ER
eSerialPort_close(CELLIDX idx)
{
CELLCB *p_cellcb;
ER ercd;
bool_t eflag = false;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!VALID_IDX(idx)) {
return(E_ID); /* ポート番号のチェック */
}
p_cellcb = GET_CELLCB(idx);
SVC(dis_dsp(), gen_ercd_sys(p_cellcb));
if (!VAR_openFlag) { /* オープン済みかのチェック */
ercd = E_OBJ;
}
else {
/*
* ハードウェア依存のクローズ処理
*/
if (loc_cpu() < 0) {
eflag = true;
}
cSIOPort_close();
VAR_openFlag = false;
if (unl_cpu() < 0) {
eflag = true;
}
/*
* セマフォの初期化
*/
if (cSendSemaphore_initialize() < 0) {
eflag = true;
}
if (cReceiveSemaphore_initialize() < 0) {
eflag = true;
}
/*
* エラーコードの設定
*/
if (eflag) {
ercd = gen_ercd_sys(p_cellcb);
}
else {
ercd = E_OK;
}
}
SVC(ena_dsp(), gen_ercd_sys(p_cellcb));
error_exit:
return(ercd);
}
void alarm_handler(intptr_t exinf)
{
ID tskid = (ID)exinf;
syslog(LOG_INFO , "Alarm handler is raised.");
SVC(iact_tsk(tskid));
}
/* Abort a periodic task */
void abort(void) {
struct task_ctrl *task = get_task_ctrl(curr_task);
task->abort = 1;
SVC(SVC_END_TASK); /* Shouldn't return (to here, at least) */
}
static char usbdev_resource_read(void *env, int *error) {
if (!usb_ready) {
if (error != NULL) {
*error = -1;
}
return 0;
}
if (error != NULL) {
*error = 0;
}
while (ring_buf_empty(&ep_rx.rx)) {
if (task_switching && !IPSR()) {
release(&usbdev_semaphore);
SVC(SVC_YIELD);
acquire(&usbdev_semaphore);
}
}
char c = (char) ep_rx.rx.buf[ep_rx.rx.start];
ep_rx.rx.start = (ep_rx.rx.start + 1) % ep_rx.rx.len;
return c;
}
/*
* シリアルポートへの1文字送信
*/
static ER_BOOL
serial_wri_chr(SPCB *p_spcb, char c)
{
bool_t buffer_full;
ER ercd, rercd;
/*
* LFの前にCRを送信する．
*/
if (c == '\n' && (p_spcb->ioctl & IOCTL_CRLF) != 0U) {
/*
* 以下のコードは再帰呼出しになっているが，引数cが'\n'の場合に
* 引数cを'\r'として呼び出すことから，この再帰呼出しは2回目の
* 呼び出しで必ず止まる．
*/
SVC(rercd = serial_wri_chr(p_spcb, '\r'), rercd);
if ((bool_t) rercd) {
SVC(rercd = wai_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_wait(rercd, p_spcb));
}
}
SVC(loc_cpu(), gen_ercd_sys(p_spcb));
if (p_spcb->snd_count == 0U && !(p_spcb->snd_stopped)
&& serial_snd_chr(p_spcb, c)) {
/*
* シリアルI/Oデバイスの送信レジスタに文字を入れることに成功し
* た場合．
*/
buffer_full = false;
}
else {
/*
* 送信バッファに文字を入れる．
*/
p_spcb->p_spinib->snd_buffer[p_spcb->snd_write_ptr] = c;
INC_PTR(p_spcb->snd_write_ptr, p_spcb->p_spinib->snd_bufsz);
p_spcb->snd_count++;
buffer_full = (p_spcb->snd_count == p_spcb->p_spinib->snd_bufsz);
}
SVC(unl_cpu(), gen_ercd_sys(p_spcb));
ercd = (ER_BOOL) buffer_full;
error_exit:
return(ercd);
}
/*
* シリアルポートへの1文字送信
*/
static ER_BOOL
serialPort_writeChar(CELLCB *p_cellcb, char c)
{
bool_t buffer_full;
ER ercd, rercd;
/*
* LFの前にCRを送信する．
*/
if (c == '\n' && (VAR_ioControl & IOCTL_CRLF) != 0U) {
/*
* 以下のコードは再帰呼出しになっているが，引数cが'\n'の場合に
* 引数cを'\r'として呼び出すことから，この再帰呼出しは2回目の
* 呼び出しで必ず止まる．
*/
SVC(rercd = serialPort_writeChar(p_cellcb, '\r'), rercd);
if ((bool_t) rercd) {
SVC(rercd = cSendSemaphore_wait(),
gen_ercd_wait(rercd, p_cellcb));
}
}
SVC(loc_cpu(), gen_ercd_sys(p_cellcb));
if (VAR_sendCount == 0U && !VAR_sendStopped
&& serialPort_sendChar(p_cellcb, c)) {
/*
* SIOの送信レジスタに文字を入れることに成功した場合．
*/
buffer_full = false;
}
else {
/*
* 送信バッファに文字を入れる．
*/
VAR_sendBuffer[VAR_sendWritePointer] = c;
INC_PTR(VAR_sendWritePointer, ATTR_sendBufferSize);
VAR_sendCount++;
buffer_full = (VAR_sendCount == ATTR_sendBufferSize);
}
SVC(unl_cpu(), gen_ercd_sys(p_cellcb));
ercd = (ER_BOOL) buffer_full;
error_exit:
return(ercd);
}
/*
* シリアルポートへの文字列送信（受け口関数）
*/
ER_UINT
eSerialPort_write(CELLIDX idx, const char *buffer, uint_t length)
{
CELLCB *p_cellcb;
bool_t buffer_full;
uint_t wricnt = 0U;
ER ercd, rercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!VALID_IDX(idx)) { /* ポート番号のチェック */
return(E_ID);
}
p_cellcb = GET_CELLCB(idx);
if (!VAR_openFlag) { /* オープン済みかのチェック */
return(E_OBJ);
}
if (VAR_errorFlag) { /* エラー状態かのチェック */
return(E_SYS);
}
buffer_full = true; /* ループの1回めはwai_semする */
while (wricnt < length) {
if (buffer_full) {
SVC(rercd = cSendSemaphore_wait(),
gen_ercd_wait(rercd, p_cellcb));
}
SVC(rercd = serialPort_writeChar(p_cellcb, *buffer++), rercd);
wricnt++;
buffer_full = (bool_t) rercd;
}
if (!buffer_full) {
SVC(cSendSemaphore_signal(), gen_ercd_sys(p_cellcb));
}
ercd = E_OK;
error_exit:
return(wricnt > 0U ? (ER_UINT) wricnt : ercd);
}
/*
* シリアルポートへの文字列送信（サービスコール）
*/
ER_UINT
serial_wri_dat(ID portid, const char *buf, uint_t len)
{
SPCB *p_spcb;
bool_t buffer_full;
uint_t wricnt = 0U;
ER ercd, rercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
p_spcb = get_spcb(portid);
if (!(p_spcb->openflag)) { /* オープン済みかのチェック */
return(E_OBJ);
}
if (p_spcb->errorflag) { /* エラー状態かのチェック */
return(E_SYS);
}
buffer_full = true; /* ループの1回めはwai_semする */
while (wricnt < len) {
if (buffer_full) {
SVC(rercd = wai_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_wait(rercd, p_spcb));
}
SVC(rercd = serial_wri_chr(p_spcb, *buf++), rercd);
wricnt++;
buffer_full = (bool_t) rercd;
}
if (!buffer_full) {
SVC(sig_sem(p_spcb->p_spinib->snd_semid), gen_ercd_sys(p_spcb));
}
ercd = E_OK;
error_exit:
return(wricnt > 0U ? (ER_UINT) wricnt : ercd);
}
void init_task(intptr_t exinf)
{
#ifndef TASK_LOOP
volatile ulong_t i;
SYSTIM stime1, stime2;
#endif /* TASK_LOOP */
/* シリアルポートのオープン */
SVC(serial_opn_por(SIO_PORTID));
SVC(serial_ctl_por(SIO_PORTID , IOCTL_CRLF));
/* 起動メッセージの出力 */
syslog(LOG_INFO , "Sample program starts.");
/* 周期ハンドラの起動 */
SVC(sta_cyc(MAIN_CYC));
/*
* ループ回数の設定
*
* TASK_LOOPがマクロ定義されている場合，測定せずに，TASK_LOOPに定
* 義された値を，タスク内でのループ回数とする．
*
* MEASURE_TWICEがマクロ定義されている場合，1回目の測定結果を捨て
* て，2回目の測定結果を使う．1回目の測定は長めの時間が出るため．
*/
#ifdef TASK_LOOP
task_loop = TASK_LOOP;
#else /* TASK_LOOP */
task_loop = LOOP_REF;
SVC(get_tim(&stime1));
for (i = 0; i < task_loop; i++);
SVC(get_tim(&stime2));
task_loop = LOOP_REF * 400UL / (stime2 - stime1);
#endif /* TASK_LOOP */
}
/*
* シリアルポートからの文字列受信（サービスコール）
*/
ER_UINT
serial_rea_dat(ID portid, char *buf, uint_t len)
{
SPCB *p_spcb;
bool_t buffer_empty;
uint_t reacnt = 0U;
char c = '\0'; /* コンパイラの警告を抑止するために初期化する */
ER ercd, rercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
p_spcb = get_spcb(portid);
if (!(p_spcb->openflag)) { /* オープン済みかのチェック */
return(E_OBJ);
}
if (p_spcb->errorflag) { /* エラー状態かのチェック */
return(E_SYS);
}
buffer_empty = true; /* ループの1回めはwai_semする */
while (reacnt < len) {
if (buffer_empty) {
SVC(rercd = wai_sem(p_spcb->p_spinib->rcv_semid),
gen_ercd_wait(rercd, p_spcb));
}
SVC(rercd = serial_rea_chr(p_spcb, &c), rercd);
*buf++ = c;
reacnt++;
buffer_empty = (bool_t) rercd;
/*
* エコーバック処理．
*/
if ((p_spcb->ioctl & IOCTL_ECHO) != 0U) {
SVC(rercd = wai_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_wait(rercd, p_spcb));
SVC(rercd = serial_wri_chr(p_spcb, c), rercd);
if (!((bool_t) rercd)) {
SVC(sig_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_sys(p_spcb));
}
}
}
if (!buffer_empty) {
SVC(sig_sem(p_spcb->p_spinib->rcv_semid), gen_ercd_sys(p_spcb));
}
ercd = E_OK;
error_exit:
return(reacnt > 0U ? (ER_UINT) reacnt : ercd);
}
/*
* シリアルポートからの文字列受信（受け口関数）
*/
ER_UINT
eSerialPort_read(CELLIDX idx, char *buffer, uint_t length)
{
CELLCB *p_cellcb;
bool_t buffer_empty;
uint_t reacnt = 0U;
char c = '\0'; /* コンパイラの警告を抑止するために初期化する */
ER ercd, rercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!VALID_IDX(idx)) { /* ポート番号のチェック */
return(E_ID);
}
p_cellcb = GET_CELLCB(idx);
if (!VAR_openFlag) { /* オープン済みかのチェック */
return(E_OBJ);
}
if (VAR_errorFlag) { /* エラー状態かのチェック */
return(E_SYS);
}
buffer_empty = true; /* ループの1回めはwai_semする */
while (reacnt < length) {
if (buffer_empty) {
SVC(rercd = cReceiveSemaphore_wait(),
gen_ercd_wait(rercd, p_cellcb));
}
SVC(rercd = serialPort_readChar(p_cellcb, &c), rercd);
*buffer++ = c;
reacnt++;
buffer_empty = (bool_t) rercd;
/*
* エコーバック処理．
*/
if ((VAR_ioControl & IOCTL_ECHO) != 0U) {
SVC(rercd = cSendSemaphore_wait(),
gen_ercd_wait(rercd, p_cellcb));
SVC(rercd = serialPort_writeChar(p_cellcb, c), rercd);
if (!((bool_t) rercd)) {
SVC(cSendSemaphore_signal(), gen_ercd_sys(p_cellcb));
}
}
}
if (!buffer_empty) {
SVC(cReceiveSemaphore_signal(), gen_ercd_sys(p_cellcb));
}
ercd = E_OK;
error_exit:
return(reacnt > 0U ? (ER_UINT) reacnt : ercd);
}
void end_task(void) {
SVC(SVC_END_TASK); /* Shouldn't return (to here, at least) */
}
void main_task(intptr_t exinf)
{
static ID tskid = TASK1;
static uint_t tskno = 1;
char_t c;
/* シリアルポートからの文字受信 */
if(serial_rea_dat(SIO_PORTID , &c , 1) > 0)
{
switch(c)
{
case 'e':
case 'z':
case 'Z':
case 'r':
message[tskno] = c;
break;
case '1':
tskid = TASK1;
tskno = 0;
break;
case '2':
tskid = TASK2;
tskno = 1;
break;
case '3':
tskid = TASK3;
tskno = 2;
break;
case 'a':
syslog(LOG_INFO, "#act_tsk(%d)", tskno);
SVC(act_tsk(tskid));
break;
case 'b':
syslog(LOG_INFO, "#sta_alm(1, 5000)");
SVC(sta_alm(ALM1 , 5000));
break;
case 'B':
syslog(LOG_INFO, "#stp_alm(1)");
SVC(stp_alm(ALM1));
break;
case 'c':
syslog(LOG_INFO, "sta_cyc(1)");
SVC(sta_cyc(CYC1));
break;
case 'C':
syslog(LOG_INFO, "stp_cyc(1)");
SVC(stp_cyc(CYC1));
break;
case 'Q':
syslog(LOG_NOTICE, "Sample program ends.");
SVC(ext_ker());
break;
default:
/* エラー表示 */
syslog(LOG_INFO , "Unknown command.");
break;
}
}
}
/*
* シリアルポートのオープン（サービスコール）
*/
ER
serial_opn_por(ID portid)
{
SPCB *p_spcb;
ER ercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
p_spcb = get_spcb(portid);
SVC(dis_dsp(), gen_ercd_sys(p_spcb));
if (p_spcb->openflag) { /* オープン済みかのチェック */
ercd = E_OBJ;
}
else {
/*
* 変数の初期化
*/
p_spcb->ioctl = (IOCTL_ECHO | IOCTL_CRLF | IOCTL_FCSND | IOCTL_FCRCV);
p_spcb->rcv_read_ptr = 0U;
p_spcb->rcv_write_ptr = 0U;
p_spcb->rcv_count = 0U;
p_spcb->rcv_fc_chr = '\0';
p_spcb->rcv_stopped = false;
p_spcb->snd_read_ptr = 0U;
p_spcb->snd_write_ptr = 0U;
p_spcb->snd_count = 0U;
p_spcb->snd_stopped = false;
/*
* これ以降，割込みを禁止する．
*/
if (loc_cpu() < 0) {
ercd = E_SYS;
goto error_exit_enadsp;
}
/*
* ハードウェア依存のオープン処理
*/
p_spcb->p_siopcb = sio_opn_por(portid, (intptr_t) p_spcb);
/*
* 受信通知コールバックを許可する．
*/
sio_ena_cbr(p_spcb->p_siopcb, SIO_RDY_RCV);
p_spcb->openflag = true;
p_spcb->errorflag = false;
if (unl_cpu() < 0) {
p_spcb->errorflag = true;
ercd = E_SYS;
goto error_exit_enadsp;
}
ercd = E_OK;
}
error_exit_enadsp:
SVC(ena_dsp(), gen_ercd_sys(p_spcb));
error_exit:
return(ercd);
}
int evaluateSyntax(int scode){
char *scodeStr=syntaxString[scode-NUMOFTOKEN];
int *temp=syntaxInner[scode-NUMOFTOKEN];
int j=1;
if(currentToken<0){
printf("EOF\n");return -1;
}
/*evaluate SPROGRAM*/
if(scode==SPROGRAM){
logPutOut(" evaluateSyntax(%s) line:%d\n",scodeStr,lastLineNumber);
for(j=1;j<=5;j++){
if(evaluateWord(temp[j])<0){
errPrint("evaluateSyntax(%s)->(%d)",scodeStr,temp[j]);
}
if(j==2){
setupProgram(tmpString);
#ifdef CSL
sprintf(cName,"%s.%s",filename,FILETYPE);
if((cFile=fopen(cName,"w"))==NULL){
exit(-1);
}
TAGCOMB("$$",idList.prog->name->name);
START(tag);
LAD("\t","gr0","0");
CALL("\t","L1");
tagnum++;
CALL("\t","FLUSH");
SVC("\t","0");
fclose(cFile);
#endif
}
}
#ifdef CSL
if((cFile=fopen(cName,"a"))==NULL) exit(-1);
END("");
//printTextFile("cFile","library.txt");
fclose(cFile);
#endif
return(scode);
}
/*evaluate SBROCK*/
else if(scode==SBROCK){
scope=idList.prog->name->name;
logPutOut(" evaluateSyntax(%s) line:%d\n",scodeStr,lastLineNumber);
do{
if(currentToken==TVAR){ //except check
pPrint(ALLOWINDENT);
if(evaluateWord(SVARDECLARE)<0){
errPrint("evaluateSyntax(%s)->(%d)",scodeStr,SVARDECLARE);
}
}else if(currentToken==TPROCEDURE){ //except check
pPrint(ALLOWINDENT);
if(evaluateWord(SSUBPROGDECLARE)<0){
errPrint("evaluateSyntax(%s)->(%d)",scodeStr,TPROCEDURE);
}
}else{
j++;
}
}while(j==1);
pPrint(RESETINDENT);
#ifdef CSL
if((cFile=fopen(cName,"a"))==NULL) exit(-1);
// TAGNAME("L");
TAGCOMB("L","1");
TAGPRINT(tag);
fclose(cFile);
#endif
if(evaluateWord(temp[3])<0){
errPrint("evaluateSyntax(%s)->(%d)",scodeStr,temp[3]);
}
return(scode);
}
/*evaluate SVARDECLARE*/
else if(scode==SVARDECLARE){
logPutOut(" evaluateSyntax(%s) line:%d\n",scodeStr,lastLineNumber);
int tempType;
for(j=1;j<=3;j++){
if(evaluateWord(temp[j])<0){
errPrint("no var(var declaretion)\n");
}
if(j==1){
pPrint(ADDINDENT,1);
}
}
if((tempType=evaluateWord(temp[j++]))<0){//j=4
errPrint("must be type\n");
}
int arrayNum=0;
if(tempType==SARRAY){
arrayNum=tempArray.arrayNum;
tempType=tempArray.type;
}
int k;
for(k=0;k<tempListCount;k++){
#ifdef CSL
if((cFile=fopen(cName,"a"))==NULL) exit(-1);
if(arrayNum==0){
if(scope==idList.prog->name->name){
TAGCOMB("$",tempList->word);
}else{
TAGCOMB2("$",tempList->word,"\%",scope);
}
DC(tag,"0");
}else{
int arr;
for(arr=0;arr<=arrayNum;arr++){
if(scope==idList.prog->name->name){
TAGCOMBARRAY("$",tempList->word,arr);
}else{
TAGCOMBARRAY2("$",tempList->word,arr,"\%",scope);
}
DC(tag,"0");
}
}
fclose(cFile);
#endif
if(registerList(tempList->word,tempType,arrayNum,lastLineNumber,POSI_VAR,scope)<0){
errPrint("double variable\n");
}
tempList=tempList->next;
}
clearWordList();
if(evaluateWord(temp[j++])<0){//j=5
errPrint("must be ;\n");
}
while(1){
int i=j=6;
if(validateTopOfSyntax(temp[i])<0){// if there is no first word, it is correct
break; //if nothing, its correct
}else{
pPrint(ALLOWINDENT);
for(i=j;i<=temp[0];i++){
if((tempType=evaluateWord(temp[i]))<0){// varlist
printf("errEI1\n");return -1;
}
if(i==8){
int arrayNum=0;
if(tempType>SARRAY){
arrayNum=tempType-SARRAY;
tempType=SARRAY;
}
int k;
for(k=0;k<tempListCount;k++){
#ifdef CSL
if((cFile=fopen(cName,"a"))==NULL) exit(-1);
if(arrayNum==0){
if(scope==idList.prog->name->name){
TAGCOMB("$",tempList->word);
}else{
TAGCOMB2("$",tempList->word,"\%",scope);
}
DC(tag,"0");
}else{
int arr;
for(arr=0;arr<=arrayNum;arr++){
if(scope==idList.prog->name->name){
TAGCOMBARRAY("$",tempList->word,arr);
}else{
TAGCOMBARRAY2("$",tempList->word,arr,"\%",scope);
}
DC(tag,"0");
}
}
fclose(cFile);
#endif
if(registerList(tempList->word,tempType,arrayNum,lastLineNumber,POSI_VAR,scope)<0){
errPrint("double variable\n");
}
tempList=tempList->next;
}
clearWordList();
}
}
}
}
}
/*evaluate SVARLIST*/
else if(scode==SVARLIST){//1:{2} patern
/*
* シリアルポートのオープン（受け口関数）
*/
ER
eSerialPort_open(CELLIDX idx)
{
CELLCB *p_cellcb;
ER ercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!VALID_IDX(idx)) {
return(E_ID); /* ポート番号のチェック */
}
p_cellcb = GET_CELLCB(idx);
SVC(dis_dsp(), gen_ercd_sys(p_cellcb));
if (VAR_openFlag) { /* オープン済みかのチェック */
ercd = E_OBJ;
}
else {
/*
* 変数の初期化
*/
VAR_ioControl = (IOCTL_ECHO | IOCTL_CRLF | IOCTL_FCSND | IOCTL_FCRCV);
VAR_receiveReadPointer = 0U;
VAR_receiveWritePointer = 0U;
VAR_receiveCount = 0U;
VAR_receiveFlowControl = '\0';
VAR_receiveStopped = false;
VAR_sendReadPointer = 0U;
VAR_sendWritePointer = 0U;
VAR_sendCount = 0U;
VAR_sendStopped = false;
/*
* これ以降，割込みを禁止する．
*/
if (loc_cpu() < 0) {
ercd = E_SYS;
goto error_exit_enadsp;
}
/*
* ハードウェア依存のオープン処理
*/
cSIOPort_open();
/*
* 受信通知コールバックを許可する．
*/
cSIOPort_enableCBR(SIOReceiveReady);
VAR_openFlag = true;
VAR_errorFlag = false;
if (unl_cpu() < 0) {
VAR_errorFlag = true;
ercd = E_SYS;
goto error_exit_enadsp;
}
ercd = E_OK;
}
error_exit_enadsp:
SVC(ena_dsp(), gen_ercd_sys(p_cellcb));
error_exit:
return(ercd);
}
