/* * File: pt_cornell_1_3_0.h * Author: brl4 * Bruce R Land, Cornell University * Created on July 10, 2018 */ /* * Copyright (c) 2004-2005, Swedish Institute of Computer Science. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * This file is part of the Contiki operating system. * * Author: Adam Dunkels * * $Id: pt.h,v 1.7 2006/10/02 07:52:56 adam Exp $ */ #include /** * \addtogroup pt * @{ */ /** * \file * Protothreads implementation. * \author * Adam Dunkels * */ #ifndef __PT_H__ #define __PT_H__ /* * Copyright (c) 2006, Adam Dunkels * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the author nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ #ifndef __UBASIC_H__ #define __UBASIC_H__ void ubasic_init(const char *program); void ubasic_run(void); int ubasic_finished(void); void statement(void) ; int ubasic_get_variable(int varnum); void ubasic_set_variable(int varum, int value); #endif /* __UBASIC_H__ */ #ifndef __TOKENIZER_H__ #define __TOKENIZER_H__ enum { TOKENIZER_ERROR, TOKENIZER_ENDOFINPUT, TOKENIZER_NUMBER, TOKENIZER_STRING, TOKENIZER_VARIABLE, TOKENIZER_LET, TOKENIZER_PRINT, TOKENIZER_IF, TOKENIZER_ELSE, TOKENIZER_FOR, //10 TOKENIZER_TO, TOKENIZER_RETURN, TOKENIZER_END, TOKENIZER_COMMA, TOKENIZER_SEMICOLON, TOKENIZER_PLUS, //20 TOKENIZER_MINUS, TOKENIZER_AND, TOKENIZER_OR, TOKENIZER_ASTR, TOKENIZER_SLASH, TOKENIZER_MOD, TOKENIZER_LEFTPAREN, TOKENIZER_RIGHTPAREN, TOKENIZER_LEFTBRACK, // Bruce land TOKENIZER_RIGHTBRACK, // Bruce land 30 TOKENIZER_LT, TOKENIZER_GT, TOKENIZER_EQ, TOKENIZER_CR, TOKENIZER_PEEK, // Bruce land TOKENIZER_POKE, // Bruce land TOKENIZER_DELAY, // Bruce land TOKENIZER_WHILE, // Bruce land TOKENIZER_REM, // Bruce land TOKENIZER_OUTPUTA }; void tokenizer_init(const char *program); void tokenizer_next(void); int tokenizer_token(void); int tokenizer_num(void); int tokenizer_variable_num(void); void tokenizer_string(char *dest, int len); int tokenizer_finished(void); void tokenizer_error_print(void); static char const *ptr, *nextptr; #endif /* __TOKENIZER_H__ */ //////////////////////// //#include "lc.h" //////////////////////// /** * \file lc.h * Local continuations * \author * Adam Dunkels * */ #ifdef DOXYGEN /** * Initialize a local continuation. * * This operation initializes the local continuation, thereby * unsetting any previously set continuation state. * * \hideinitializer */ #define LC_INIT(lc) /** * Set a local continuation. * * The set operation saves the state of the function at the point * where the operation is executed. As far as the set operation is * concerned, the state of the function does not include the * call-stack or local (automatic) variables, but only the program * counter and such CPU registers that needs to be saved. * * \hideinitializer */ #define LC_SET(lc) /** * Resume a local continuation. * * The resume operation resumes a previously set local continuation, thus * restoring the state in which the function was when the local * continuation was set. If the local continuation has not been * previously set, the resume operation does nothing. * * \hideinitializer */ #define LC_RESUME(lc) /** * Mark the end of local continuation usage. * * The end operation signifies that local continuations should not be * used any more in the function. This operation is not needed for * most implementations of local continuation, but is required by a * few implementations. * * \hideinitializer */ #define LC_END(lc) /** * \var typedef lc_t; * * The local continuation type. * * \hideinitializer */ #endif /* DOXYGEN */ //#ifndef __LC_H__ //#define __LC_H__ //#ifdef LC_INCLUDE //#include LC_INCLUDE //#else ///////////////////////////// //#include "lc-switch.h" ///////////////////////////// //#ifndef __LC_SWITCH_H__ //#define __LC_SWITCH_H__ /* WARNING! lc implementation using switch() does not work if an LC_SET() is done within another switch() statement! */ /** \hideinitializer */ /* typedef unsigned short lc_t; #define LC_INIT(s) s = 0; #define LC_RESUME(s) switch(s) { case 0: #define LC_SET(s) s = __LINE__; case __LINE__: #define LC_END(s) } #endif /* __LC_SWITCH_H__ */ /** @} */ //#endif /* LC_INCLUDE */ //#endif /* __LC_H__ */ /** @} */ /** @} */ ///////////////////////////// //#include "lc-addrlabels.h" ///////////////////////////// #ifndef __LC_ADDRLABELS_H__ #define __LC_ADDRLABELS_H__ /** \hideinitializer */ typedef void * lc_t; #define LC_INIT(s) s = NULL #define LC_RESUME(s) \ do { \ if(s != NULL) { \ goto *s; \ } \ } while(0) #define LC_CONCAT2(s1, s2) s1##s2 #define LC_CONCAT(s1, s2) LC_CONCAT2(s1, s2) #define LC_SET(s) \ do { \ LC_CONCAT(LC_LABEL, __LINE__): \ (s) = &&LC_CONCAT(LC_LABEL, __LINE__); \ } while(0) #define LC_END(s) #endif /* __LC_ADDRLABELS_H__ */ ////////////////////////////////////////// struct pt { lc_t lc; }; #define PT_WAITING 0 #define PT_YIELDED 1 #define PT_EXITED 2 #define PT_ENDED 3 /** * \name Initialization * @{ */ /** * Initialize a protothread. * * Initializes a protothread. Initialization must be done prior to * starting to execute the protothread. * * \param pt A pointer to the protothread control structure. * * \sa PT_SPAWN() * * \hideinitializer */ #define PT_INIT(pt) LC_INIT((pt)->lc) /** @} */ /** * \name Declaration and definition * @{ */ /** * Declaration of a protothread. * * This macro is used to declare a protothread. All protothreads must * be declared with this macro. * * \param name_args The name and arguments of the C function * implementing the protothread. * * \hideinitializer */ #define PT_THREAD(name_args) char name_args /** * Declare the start of a protothread inside the C function * implementing the protothread. * * This macro is used to declare the starting point of a * protothread. It should be placed at the start of the function in * which the protothread runs. All C statements above the PT_BEGIN() * invokation will be executed each time the protothread is scheduled. * * \param pt A pointer to the protothread control structure. * * \hideinitializer */ #define PT_BEGIN(pt) { char PT_YIELD_FLAG = 1; LC_RESUME((pt)->lc) /** * Declare the end of a protothread. * * This macro is used for declaring that a protothread ends. It must * always be used together with a matching PT_BEGIN() macro. * * \param pt A pointer to the protothread control structure. * * \hideinitializer */ #define PT_END(pt) LC_END((pt)->lc); PT_YIELD_FLAG = 0; \ PT_INIT(pt); return PT_ENDED; } /** @} */ /** * \name Blocked wait * @{ */ /** * Block and wait until condition is true. * * This macro blocks the protothread until the specified condition is * true. * * \param pt A pointer to the protothread control structure. * \param condition The condition. * * \hideinitializer */ #define PT_WAIT_UNTIL(pt, condition) \ do { \ LC_SET((pt)->lc); \ if(!(condition)) { \ return PT_WAITING; \ } \ } while(0) /** * Block and wait while condition is true. * * This function blocks and waits while condition is true. See * PT_WAIT_UNTIL(). * * \param pt A pointer to the protothread control structure. * \param cond The condition. * * \hideinitializer */ #define PT_WAIT_WHILE(pt, cond) PT_WAIT_UNTIL((pt), !(cond)) /** @} */ /** * \name Hierarchical protothreads * @{ */ /** * Block and wait until a child protothread completes. * * This macro schedules a child protothread. The current protothread * will block until the child protothread completes. * * \note The child protothread must be manually initialized with the * PT_INIT() function before this function is used. * * \param pt A pointer to the protothread control structure. * \param thread The child protothread with arguments * * \sa PT_SPAWN() * * \hideinitializer */ #define PT_WAIT_THREAD(pt, thread) PT_WAIT_WHILE((pt), PT_SCHEDULE(thread)) /** * Spawn a child protothread and wait until it exits. * * This macro spawns a child protothread and waits until it exits. The * macro can only be used within a protothread. * * \param pt A pointer to the protothread control structure. * \param child A pointer to the child protothread's control structure. * \param thread The child protothread with arguments * * \hideinitializer */ #define PT_SPAWN(pt, child, thread) \ do { \ PT_INIT((child)); \ PT_WAIT_THREAD((pt), (thread)); \ } while(0) /** @} */ /** * \name Exiting and restarting * @{ */ /** * Restart the protothread. * * This macro will block and cause the running protothread to restart * its execution at the place of the PT_BEGIN() call. * * \param pt A pointer to the protothread control structure. * * \hideinitializer */ #define PT_RESTART(pt) \ do { \ PT_INIT(pt); \ return PT_WAITING; \ } while(0) /** * Exit the protothread. * * This macro causes the protothread to exit. If the protothread was * spawned by another protothread, the parent protothread will become * unblocked and can continue to run. * * \param pt A pointer to the protothread control structure. * * \hideinitializer */ #define PT_EXIT(pt) \ do { \ PT_INIT(pt); \ return PT_EXITED; \ } while(0) /** @} */ /** * \name Calling a protothread * @{ */ /** * Schedule a protothread. * * This function shedules a protothread. The return value of the * function is non-zero if the protothread is running or zero if the * protothread has exited. * * \param f The call to the C function implementing the protothread to * be scheduled * * \hideinitializer */ #define PT_SCHEDULE(f) ((f) < PT_EXITED) //#define PT_SCHEDULE(f) ((f)) /** @} */ /** * \name Yielding from a protothread * @{ */ /** * Yield from the current protothread. * * This function will yield the protothread, thereby allowing other * processing to take place in the system. * * \param pt A pointer to the protothread control structure. * * \hideinitializer */ #define PT_YIELD(pt) \ do { \ PT_YIELD_FLAG = 0; \ LC_SET((pt)->lc); \ if(PT_YIELD_FLAG == 0) { \ return PT_YIELDED; \ } \ } while(0) /** * \brief Yield from the protothread until a condition occurs. * \param pt A pointer to the protothread control structure. * \param cond The condition. * * This function will yield the protothread, until the * specified condition evaluates to true. * * * \hideinitializer */ #define PT_YIELD_UNTIL(pt, cond) \ do { \ PT_YIELD_FLAG = 0; \ LC_SET((pt)->lc); \ if((PT_YIELD_FLAG == 0) || !(cond)) { \ return PT_YIELDED; \ } \ } while(0) /** @} */ #endif /* __PT_H__ */ #ifndef __PT_SEM_H__ #define __PT_SEM_H__ //#include "pt.h" struct pt_sem { unsigned int count; }; /** * Initialize a semaphore * * This macro initializes a semaphore with a value for the * counter. Internally, the semaphores use an "unsigned int" to * represent the counter, and therefore the "count" argument should be * within range of an unsigned int. * * \param s (struct pt_sem *) A pointer to the pt_sem struct * representing the semaphore * * \param c (unsigned int) The initial count of the semaphore. * \hide initializer */ #define PT_SEM_INIT(s, c) (s)->count = c /** * Wait for a semaphore * * This macro carries out the "wait" operation on the semaphore. The * wait operation causes the protothread to block while the counter is * zero. When the counter reaches a value larger than zero, the * protothread will continue. * * \param pt (struct pt *) A pointer to the protothread (struct pt) in * which the operation is executed. * * \param s (struct pt_sem *) A pointer to the pt_sem struct * representing the semaphore * * \hideinitializer */ #define PT_SEM_WAIT(pt, s) \ do { \ PT_WAIT_UNTIL(pt, (s)->count > 0); \ --(s)->count; \ } while(0) /** * Signal a semaphore * * This macro carries out the "signal" operation on the semaphore. The * signal operation increments the counter inside the semaphore, which * eventually will cause waiting protothreads to continue executing. * * \param pt (struct pt *) A pointer to the protothread (struct pt) in * which the operation is executed. * * \param s (struct pt_sem *) A pointer to the pt_sem struct * representing the semaphore * * \hideinitializer */ #define PT_SEM_SIGNAL(pt, s) ++(s)->count #endif /* __PT_SEM_H__ */ //===================================================================== //=== BRL4 additions for PIC 32 ======================================= //===================================================================== // macro to time a thread execution interveal in millisec // max time 4000 sec //#include //#include //#include "config.h" #define PT_YIELD_TIME_msec(delay_time) \ do { static unsigned int time_thread ;\ time_thread = time_tick_millsec + (unsigned int)delay_time ; \ PT_YIELD_UNTIL(pt, (time_tick_millsec >= time_thread)); \ } while(0); // macro to return system time #define PT_GET_TIME() (time_tick_millsec) // init rate sehcduler //#define PT_INIT(pt, priority) LC_INIT((pt)->lc ; (pt)->pri = priority) //PT_PRIORITY_INIT #define PT_RATE_INIT() int pt_pri_count = 0; // maitain proority frame count //PT_PRIORITY_LOOP maitains a counter used to control execution #define PT_RATE_LOOP() pt_pri_count = (pt_pri_count+1) & 0xf ; // schecedule priority thread //PT_PRIORITY_SCHEDULE // 5 levels // rate 0 is highest -- every time thru loop // priority 1 -- every 2 times thru loop // priority 2 -- every 4 times thru loop // 3 is -- every 8 times thru loop #define PT_RATE_SCHEDULE(f,rate) \ if((rate==0) | \ (rate==1 && ((pt_pri_count & 0b1)==0) ) | \ (rate==2 && ((pt_pri_count & 0b11)==0) ) | \ (rate==3 && ((pt_pri_count & 0b111)==0)) | \ (rate==4 && ((pt_pri_count & 0b1111)==0))) \ PT_SCHEDULE(f); // macro to use 4 bit DAC as debugger output // level range 0-15; duration in microseconds // -- with zero meaning HOLD it on forever //while((signed int)ReadTimer45() <= time_hold){}; // time_hold = duration + ReadTimer45() ; #define PT_DEBUG_VALUE(level, duration) \ do { static int i ; \ CVRCON = CVRCON_setup | (level & 0xf); \ if (duration>0){ \ for (i=0; icount=1 #define PT_SEM_CLEAR(s) (s)->count=0 #define PT_SEM_READ(s) (s)->count #define PT_SEM_ACCEPT(s) \ s->count; \ if (s->count) s->count-- ; \ //==================================================================== // IMPROVED SCHEDULER // === thread structures === // thread control structs // A modified scheduler static struct pt pt_sched ; // count of defined tasks int pt_task_count = 0 ; // The task structure struct ptx { struct pt pt; // thread context int num; // thread number char (*pf)(struct pt *pt); // pointer to thread function int rate; }; // === extended structure for scheduler =============== // an array of task structures #define MAX_THREADS 10 static struct ptx pt_thread_list[MAX_THREADS]; // see https://github.com/edartuz/c-ptx/tree/master/src // and the license above // add an entry to the thread list //struct ptx *pt_add( char (*pf)(struct pt *pt), int rate) { int pt_add( char (*pf)(struct pt *pt), int rate) { if (pt_task_count < (MAX_THREADS)) { // get the current thread table entry struct ptx *ptx = &pt_thread_list[pt_task_count]; // enter the tak data into the thread table ptx->num = pt_task_count; // function pointer ptx->pf = pf; // rate scheduler rate ptx->rate = rate ; PT_INIT( &ptx->pt ); // count of number of defined threads pt_task_count++; // return current entry return pt_task_count-1; } return NULL; } /* Scheduler Copyright (c) 2014 edartuz Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ // === Scheduler Thread ================================================= // update a 1 second tick counter // schedulser code was almost copied from // https://github.com/edartuz/c-ptx // see license above // choose schedule method #define SCHED_ROUND_ROBIN 0 #define SCHED_RATE 1 int pt_sched_method = SCHED_ROUND_ROBIN ; #define PT_SET_RATE(thread_num, new_rate) pt_thread_list[thread_num].rate = new_rate #define PT_GET_RATE(thread_num) pt_thread_list[thread_num].rate static PT_THREAD (protothread_sched(struct pt *pt)) { PT_BEGIN(pt); // set up rate counter PT_RATE_INIT() static int i, rate; if (pt_sched_method==SCHED_ROUND_ROBIN){ while(1) { // test stupid round-robin // on all defined threads struct ptx *ptx = &pt_thread_list[0]; // step thru all defined threads // -- loop can have more than one initialization or increment/decrement, // -- separated using comma operator. But it can have only one condition. for (i=0; ipt); } // Never yields! // NEVER exit while! } // END WHILE(1) } // end if(pt_sched_method==SCHED_ROUND_ROBIN) else if (pt_sched_method==SCHED_RATE){ while(1) { PT_RATE_LOOP() ; // test stupid round-robin // on all defined threads struct ptx *ptx = &pt_thread_list[0]; // step thru all defined threads // -- loop can have more than one initialization or increment/decrement, // -- separated using comma operator. But it can have only one condition. for (i=0; ipt); } } // Never yields! // NEVER exit while! } // END WHILE(1) } //end if (pt_sched_method==SCHED_RATE) PT_END(pt); } // scheduler thread //==================================================================== //=== serial setup =================================================== //#ifdef use_uart_serial /////////////////////////// // UART parameters #define PB_DIVISOR (1 << OSCCONbits.PBDIV) // read the peripheral bus divider, FPBDIV #define PB_FREQ sys_clock/PB_DIVISOR // periperhal bus frequency #define clrscr() printf( "\x1b[2J") #define home() printf( "\x1b[H") #define pcr() printf( '\r') #define crlf putchar(0x0a); putchar(0x0d); #define backspace 0x7f // make sure your backspace matches this! #define max_chars 1000 // for input/output buffer // PuTTY serial terminal control codes // see // http://ascii-table.com/ansi-escape-sequences-vt-100.php #define cursor_pos(line,column) printf("\x1b[%02d;%02dH",line,column) #define clr_right printf("\x1b[K") // from http://www.comptechdoc.org/os/linux/howlinuxworks/linux_hlvt100.html // and colors from http://www.termsys.demon.co.uk/vtansi.htm #define green_text printf("\x1b[32m") #define yellow_text printf("\x1b[33m") #define red_text printf("\x1b[31m") #define rev_text printf("\x1b[7m") #define normal_text printf("\x1b[0m") //==================================================================== // build a string from the UART2 ///////////// // assuming that a HUMAN is typing at a terminal! ////////////////////////////////////////////// char PT_term_buffer[max_chars]; int PT_GetSerialBuffer(struct pt *pt) { static char character; static int num_char; // mark the beginnning of the input thread PT_BEGIN(pt); num_char = 0; // clear buffer memset(PT_term_buffer, 0, max_chars); while(num_char < max_chars) { // get the character // yield until there is a valid character so that other // threads can execute PT_YIELD_UNTIL(pt, UARTReceivedDataIsAvailable(UART2)); // while(!UARTReceivedDataIsAvailable(UART2)){}; character = UARTGetDataByte(UART2); PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, character); // unomment to check backspace character!!! //printf("--%x--",character ); // end line if(character == '\r'){ PT_term_buffer[num_char] = 0; // zero terminate the string //crlf; // send a new line PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, '\n'); break; } // backspace else if (character == backspace){ PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, ' '); PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, backspace); num_char--; // check for buffer underflow if (num_char<0) {num_char = 0 ;} } else {PT_term_buffer[num_char++] = character ;} //if (character == backspace) } //end while(num_char < max_size) // kill this input thread, to allow spawning thread to execute PT_EXIT(pt); // and indicate the end of the thread PT_END(pt); } //==================================================================== // build a string from the UART2 ///////////// // assuming MACHINE input ////////////////////////////////////////////// // !!! you MUST specify EITHER a termination character or a count!! ////////////////////////////////////////////// // -- terminator character could be '\r' // or any other characcter, e.g. '#' or can be set to ZERO // if there is no termination character // -- Termination count will return after N characters, regardless of // the terminator character // Set to ZERO if there is no termination count. // -- Termination time is the longest the routine will wait // for a terminator event in milliseconds char PT_terminate_char, PT_terminate_count ; // terminate time default million seconds int PT_terminate_time = 1000000000 ; // timeout return value int PT_timeout = 0; // system time updated in TIMER5 ISR below volatile unsigned int time_tick_millsec ; int PT_GetMachineBuffer(struct pt *pt) { static char character; static unsigned int num_char, start_time; // mark the beginnning of the input thread PT_BEGIN(pt); // actual number received num_char = 0; //record milliseconds for timeout calculation start_time = time_tick_millsec ; // clear timeout flag PT_timeout = 0; // clear input buffer memset(PT_term_buffer, 0, max_chars); while(num_char < max_chars) { // get the character // yield until there is a valid character so that other // threads can execute PT_YIELD_UNTIL(pt, UARTReceivedDataIsAvailable(UART2) || ((PT_terminate_time>0) && (time_tick_millsec >= PT_terminate_time+start_time))); // grab the character from the uart buffer character = UARTGetDataByte(UART2); // Terminate on character match if ((character>0) && (character == PT_terminate_char)) { PT_term_buffer[num_char] = 0; // zero terminate the string // and leave the while loop break; } // Terminate on count else if ( ((PT_terminate_count>0) && (num_char+1 >= PT_terminate_count))){ // record the last character PT_term_buffer[num_char++] = character ; // and terminate PT_term_buffer[num_char] = 0; // zero terminate the string // and leave the while loop break; } // terminate on timeout else if ((PT_terminate_time>0) && (time_tick_millsec >= PT_terminate_time+start_time)){ // set the timeout flag PT_timeout = 1; // clear (probably invalid) input buffer memset(PT_term_buffer, 0, max_chars); // and leave the while loop break ; } // continue recording input characters else { PT_term_buffer[num_char++] = character ; } } //end while(num_char < max_size) // kill this input thread, to allow spawning thread to execute PT_EXIT(pt); // and indicate the end of the thread PT_END(pt); } //==================================================================== // === send a string to the UART2 ==================================== char PT_send_buffer[max_chars]; int num_send_chars ; int PutSerialBuffer(struct pt *pt) { PT_BEGIN(pt); num_send_chars = 0; while (PT_send_buffer[num_send_chars] != 0){ PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, PT_send_buffer[num_send_chars]); num_send_chars++; } // kill this output thread, to allow spawning thread to execute PT_EXIT(pt); // and indicate the end of the thread PT_END(pt); } //==================================================================== // === DMA send string to the UART2 ================================== int PT_DMA_PutSerialBuffer(struct pt *pt) { PT_BEGIN(pt); //mPORTBSetBits(BIT_0); // check for null string if (PT_send_buffer[0]==0)PT_EXIT(pt); // sent the first character PT_YIELD_UNTIL(pt, UARTTransmitterIsReady(UART2)); UARTSendDataByte(UART2, PT_send_buffer[0]); //DmaChnStartTxfer(DMA_CHANNEL1, DMA_WAIT_NOT, 0); // start the DMA DmaChnEnable(DMA_CHANNEL1); // wait for DMA done //mPORTBClearBits(BIT_0); PT_YIELD_UNTIL(pt, DmaChnGetEvFlags(DMA_CHANNEL1) & DMA_EV_BLOCK_DONE); //wait until the transmit buffer is empty PT_YIELD_UNTIL(pt, U2STA&0x100); // kill this output thread, to allow spawning thread to execute PT_EXIT(pt); // and indicate the end of the thread PT_END(pt); } //#endif //#ifdef use_uart_serial //====================================================================== // vref confing (if used) int CVRCON_setup ; // force full context save //int w; //void waste(void){w=1;}; // Timer 5 interrupt handler /////// // ipl2 means "interrupt priority level 2" void __ISR(_TIMER_5_VECTOR, IPL2AUTO) Timer5Handler(void) //_TIMER_5_VECTOR { // clear the interrupt flag mT5ClearIntFlag(); //count milliseconds time_tick_millsec++ ; //waste(); } void PT_setup (void) { // Configure the device for maximum performance but do not change the PBDIV // Given the options, this function will change the flash wait states, RAM // wait state and enable prefetch cache but will not change the PBDIV. // The PBDIV value is already set via the pragma FPBDIV option above.. SYSTEMConfig(sys_clock, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE); ANSELA =0; //make sure analog is cleared ANSELB =0; #ifdef use_uart_serial // === init the uart2 =================== // SET UART i/o PINS // The RX pin must be one of the Group 2 input pins // RPA1, RPB1, RPB5, RPB8, RPB11 PPSInput (2, U2RX, RPA1); //Assign U2RX to pin RPA1 -- // The TX pin must be one of the Group 4 output pins // RPA3, RPB0, RPB9, RPB10, RPB14 PPSOutput(4, RPB10, U2TX); //Assign U2TX to pin RPB10 -- UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY); UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1); UARTSetDataRate(UART2, pb_clock, BAUDRATE); UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX)); // Feel free to comment this out clrscr(); home(); // reverse video control codes normal_text; rev_text ; printf("...protothreads 1_3_0 07/18/18..."); normal_text ; // === set up DMA for UART output ========= // configure the channel and enable end-on-match DmaChnOpen(DMA_CHANNEL1, DMA_CHN_PRI2, DMA_OPEN_MATCH); // trigger a byte everytime the UART is empty DmaChnSetEventControl(DMA_CHANNEL1, DMA_EV_START_IRQ_EN|DMA_EV_MATCH_EN|DMA_EV_START_IRQ(_UART2_TX_IRQ)); // source and destination DmaChnSetTxfer(DMA_CHANNEL1, PT_send_buffer+1, (void*)&U2TXREG, max_chars, 1, 1); // signal when done DmaChnSetEvEnableFlags(DMA_CHANNEL1, DMA_EV_BLOCK_DONE); // set null as ending character (of a string) DmaChnSetMatchPattern(DMA_CHANNEL1, 0x00); #endif //#ifdef use_uart_serial // ===Set up timer5 ====================== // timer 5: on, interrupts, internal clock, // set up to count millsec OpenTimer5(T5_ON | T5_SOURCE_INT | T5_PS_1_1 , pb_clock/1000); // set up the timer interrupt with a priority of 2 ConfigIntTimer5(T5_INT_ON | T5_INT_PRIOR_2); mT5ClearIntFlag(); // and clear the interrupt flag // zero the system time tick time_tick_millsec = 0; //=== Set up VREF as a debugger output ======= #ifdef use_vref_debug // set up the Vref pin and use as a DAC // enable module| eanble output | use low range output | use internal reference | desired step CVREFOpen( CVREF_ENABLE | CVREF_OUTPUT_ENABLE | CVREF_RANGE_LOW | CVREF_SOURCE_AVDD | CVREF_STEP_0 ); // And read back setup from CVRCON for speed later // 0x8060 is enabled with output enabled, Vdd ref, and 0-0.6(Vdd) range CVRCON_setup = CVRCON; //CVRCON = 0x8060 from Tahmid http://tahmidmc.blogspot.com/ #endif //#ifdef use_vref_debug } /////////////////////////////////////////////////////////////////////////// /// uBASIC /////////////////////////////////////////////////////////////////////////// /* * Copyright (c) 2006, Adam Dunkels * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the author nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * */ /////////////////////////////////////////////////////////// // ignore tabs, returns, newlines // change string delimiter " to ' // fixed init function // // Bruce Land Cornell April 2010 /////////////////////////////////////////////////////////// #define DEBUG 0 #if DEBUG #define DEBUG_PRINTF(...) printf(__VA_ARGS__) #else #define DEBUG_PRINTF(...) #endif //#include "tokenizer.h" #include #include #include static char const *ptr, *nextptr; #define MAX_NUMLEN 8 struct keyword_token { char *keyword; int token; }; static int current_token = TOKENIZER_ERROR; static const struct keyword_token keywords[] = { {"print", TOKENIZER_PRINT}, {"if", TOKENIZER_IF}, {"else", TOKENIZER_ELSE}, {"for", TOKENIZER_FOR}, {"to", TOKENIZER_TO}, {"return", TOKENIZER_RETURN}, {"end", TOKENIZER_END}, {"peek", TOKENIZER_PEEK}, //brl4 {"poke", TOKENIZER_POKE}, //brl4 {"delay", TOKENIZER_DELAY}, //brl4 {"while", TOKENIZER_WHILE}, //brl4 {"outputA", TOKENIZER_OUTPUTA}, //brl4 {NULL, TOKENIZER_ERROR} }; // {"#", TOKENIZER_REM}, //brl4 /*---------------------------------------------------------------------------*/ static int singlechar(void) { if(*ptr == ';') { //(*ptr == '\n') return TOKENIZER_CR; } else if(*ptr == ',') { return TOKENIZER_COMMA; } else if(*ptr == '#') { return TOKENIZER_REM; } else if(*ptr == '+') { return TOKENIZER_PLUS; } else if(*ptr == '-') { return TOKENIZER_MINUS; } else if(*ptr == '&') { return TOKENIZER_AND; } else if(*ptr == '|') { return TOKENIZER_OR; } else if(*ptr == '*') { return TOKENIZER_ASTR; } else if(*ptr == '/') { return TOKENIZER_SLASH; } else if(*ptr == '%') { return TOKENIZER_MOD; } else if(*ptr == '(') { return TOKENIZER_LEFTPAREN; } else if(*ptr == ')') { return TOKENIZER_RIGHTPAREN; } else if(*ptr == '{') { return TOKENIZER_LEFTBRACK; } else if(*ptr == '}') { return TOKENIZER_RIGHTBRACK; } else if(*ptr == '<') { return TOKENIZER_LT; } else if(*ptr == '>') { return TOKENIZER_GT; } else if(*ptr == '=') { return TOKENIZER_EQ; } return 0; } /*---------------------------------------------------------------------------*/ // ==================================================================== //void ubasic_run(void) static int get_next_token(void) { struct keyword_token const *kt; int i; DEBUG_PRINTF("get_next_token(): '%s'\n", ptr); if(*ptr == 0) { return TOKENIZER_ENDOFINPUT; } if(isdigit(*ptr) || ((*ptr)=='-' && isdigit(*(ptr+1)))) { //if(isdigit(*ptr)) { for(i = 1; i < MAX_NUMLEN; ++i) { if(!isdigit(ptr[i])) { if(i > 0) { nextptr = ptr + i; return TOKENIZER_NUMBER; } else { DEBUG_PRINTF("get_next_token: error due to too short number\n"); return TOKENIZER_ERROR; } } if(!isdigit(ptr[i])) { DEBUG_PRINTF("get_next_token: error due to malformed number\n"); return TOKENIZER_ERROR; } } DEBUG_PRINTF("get_next_token: error due to too long number\n"); return TOKENIZER_ERROR; } else if(singlechar()) { nextptr = ptr + 1; return singlechar(); } else if(*ptr == '\'') { nextptr = ptr; do { ++nextptr; } while(*nextptr != '\''); ++nextptr; return TOKENIZER_STRING; } else { for(kt = keywords; kt->keyword != NULL; ++kt) { if(strncmp(ptr, kt->keyword, strlen(kt->keyword)) == 0) { nextptr = ptr + strlen(kt->keyword); return kt->token; } } } if(*ptr >= 'a' && *ptr <= 'z') { nextptr = ptr + 1; return TOKENIZER_VARIABLE; } return TOKENIZER_ERROR; } /*---------------------------------------------------------------------------*/ // CHANGED -- BRL4 -- failed if first char was not a token void tokenizer_init(const char *program) { ptr = program; nextptr = program; tokenizer_next(); //current_token = get_next_token(); } /*---------------------------------------------------------------------------*/ int tokenizer_token(void) { return current_token; } /*---------------------------------------------------------------------------*/ void tokenizer_next(void) { if(tokenizer_finished()) { return; } DEBUG_PRINTF("tokenizer_next: %p\n", nextptr); ptr = nextptr; // CHANGED brl4 -- ignore tabs, newlines while(*ptr == ' ' | *ptr == '\t' | *ptr == '\n' | *ptr == '\r') { ++ptr; } current_token = get_next_token(); DEBUG_PRINTF("tokenizer_next: '%s' %d\n", ptr, current_token); return; } /*---------------------------------------------------------------------------*/ int tokenizer_num(void) { return atoi(ptr); } /*---------------------------------------------------------------------------*/ void tokenizer_string(char *dest, int len) { char *string_end; int string_len; if(tokenizer_token() != TOKENIZER_STRING) { return; } string_end = strchr(ptr + 1, '\''); if(string_end == NULL) { return; } string_len = string_end - ptr - 1; if(len < string_len) { string_len = len; } memcpy(dest, ptr + 1, string_len); dest[string_len] = 0; } /*---------------------------------------------------------------------------*/ void tokenizer_error_print(void) { DEBUG_PRINTF("tokenizer_error_print: '%s'\n", ptr); } /*---------------------------------------------------------------------------*/ int tokenizer_finished(void) { return *ptr == 0 || current_token == TOKENIZER_ENDOFINPUT; } /*---------------------------------------------------------------------------*/ int tokenizer_variable_num(void) { return *ptr - 'a'; } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ int tokenizer_ptr(void) { return ptr; } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ void tokenizer_ptr_set(char* p) { ptr = p ; current_token = get_next_token(); } /*---------------------------------------------------------------------------*/ #define DEBUG 0 #if DEBUG #define DEBUG_PRINTF(...) printf(__VA_ARGS__) #else #define DEBUG_PRINTF(...) #endif //#include "ubasic.h" //#include "tokenizer.h" //#include "pt_cornell_1_3_0.h" #include /* printf() */ #include /* exit() */ static char const *program_ptr; #define MAX_STRINGLEN 40 static char string[MAX_STRINGLEN]; #define MAX_VARLEN 4 #define MAX_VARNUM 26 static int variables[MAX_VARNUM]; //char static int ended; static int expr(void); static void line_statement(void); void statement(void); /*---------------------------------------------------------------------------*/ void ubasic_init(const char *program) { program_ptr = program; // for_stack_ptr = gosub_stack_ptr = 0; tokenizer_init(program); ended = 0; } /*---------------------------------------------------------------------------*/ static void accept(int token) { if(token != tokenizer_token()) { DEBUG_PRINTF("Token not what was expected (expected %d, got %d)\n", token, tokenizer_token()); tokenizer_error_print(); exit(1); } DEBUG_PRINTF("Expected %d, got it\n", token); tokenizer_next(); } /*---------------------------------------------------------------------------*/ static int varfactor(void) { int r; DEBUG_PRINTF("varfactor: obtaining %d from variable %d\n", variables[tokenizer_variable_num()], tokenizer_variable_num()); r = ubasic_get_variable(tokenizer_variable_num()); accept(TOKENIZER_VARIABLE); return r; } /*---------------------------------------------------------------------------*/ static int factor(void) { int r; DEBUG_PRINTF("factor: token %d\n", tokenizer_token()); switch(tokenizer_token()) { case TOKENIZER_NUMBER: r = tokenizer_num(); DEBUG_PRINTF("factor: number %d\n", r); accept(TOKENIZER_NUMBER); break; case TOKENIZER_LEFTPAREN: accept(TOKENIZER_LEFTPAREN); r = expr(); accept(TOKENIZER_RIGHTPAREN); break; default: r = varfactor(); break; } return r; } /*---------------------------------------------------------------------------*/ static int term(void) { int f1, f2; int op; f1 = factor(); op = tokenizer_token(); DEBUG_PRINTF("term: token %d\n", op); while(op == TOKENIZER_ASTR || op == TOKENIZER_SLASH || op == TOKENIZER_MOD) { tokenizer_next(); f2 = factor(); DEBUG_PRINTF("term: %d %d %d\n", f1, op, f2); switch(op) { case TOKENIZER_ASTR: f1 = f1 * f2; break; case TOKENIZER_SLASH: f1 = f1 / f2; break; case TOKENIZER_MOD: f1 = f1 % f2; break; } op = tokenizer_token(); } DEBUG_PRINTF("term: %d\n", f1); return f1; } /*---------------------------------------------------------------------------*/ static int expr(void) { int t1, t2; int op; t1 = term(); op = tokenizer_token(); DEBUG_PRINTF("expr: token %d\n", op); while(op == TOKENIZER_PLUS || op == TOKENIZER_MINUS || op == TOKENIZER_AND || op == TOKENIZER_OR) { tokenizer_next(); t2 = term(); DEBUG_PRINTF("expr: %d %d %d\n", t1, op, t2); switch(op) { case TOKENIZER_PLUS: t1 = t1 + t2; break; case TOKENIZER_MINUS: t1 = t1 - t2; break; case TOKENIZER_AND: t1 = t1 & t2; break; case TOKENIZER_OR: t1 = t1 | t2; break; } op = tokenizer_token(); } DEBUG_PRINTF("expr: %d\n", t1); return t1; } /*---------------------------------------------------------------------------*/ static int relation(void) { int r1, r2; int op; r1 = expr(); op = tokenizer_token(); DEBUG_PRINTF("relation: token %d\n", op); while(op == TOKENIZER_LT || op == TOKENIZER_GT || op == TOKENIZER_EQ) { tokenizer_next(); r2 = expr(); DEBUG_PRINTF("relation: %d %d %d\n", r1, op, r2); switch(op) { case TOKENIZER_LT: r1 = r1 < r2; break; case TOKENIZER_GT: r1 = r1 > r2; break; case TOKENIZER_EQ: r1 = r1 == r2; break; } op = tokenizer_token(); } return r1; } /*---------------------------------------------------------------------------*/ static void print_statement(void) { accept(TOKENIZER_PRINT); do { DEBUG_PRINTF("Print loop\n"); if(tokenizer_token() == TOKENIZER_STRING) { tokenizer_string(string, sizeof(string)); printf("%s", string); tokenizer_next(); } else if(tokenizer_token() == TOKENIZER_COMMA) { printf(" "); tokenizer_next(); //} else if(tokenizer_token() == TOKENIZER_SEMICOLON) { // tokenizer_next(); } else if(tokenizer_token() == TOKENIZER_VARIABLE || tokenizer_token() == TOKENIZER_NUMBER) { printf("%d", expr()); } else { break; } } while(tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ENDOFINPUT); printf("\n"); DEBUG_PRINTF("End of print\n"); tokenizer_next(); } /*---------------------------------------------------------------------------*/ /* source format: if c<255 { \ print \"button pushed\"; \ print \"hi\"; \ delay(200); } \ else { \ print \"else\"; \ print \"made it\"; } ; \ */ static void if_statement(void) { int r ; char bracket_depth; accept(TOKENIZER_IF); r = relation(); DEBUG_PRINTF("if_statement: relation %d\n", r); accept(TOKENIZER_LEFTBRACK); bracket_depth = 1; if(r) { statement(); // statement() ends with new token // more than one statement? while(tokenizer_token() != TOKENIZER_RIGHTBRACK) { statement(); } // is there an 'else' clause tokenizer_next() ; if (tokenizer_token() == TOKENIZER_ELSE) { // if so, skip over 'else' part of the 'if' statement // need to count brackets for nesting bracket_depth = 0; do { tokenizer_next(); if (tokenizer_token() == TOKENIZER_RIGHTBRACK) bracket_depth--; if (tokenizer_token() == TOKENIZER_LEFTBRACK) bracket_depth++; } while(tokenizer_token() != TOKENIZER_RIGHTBRACK || bracket_depth>0) ; do { tokenizer_next(); } while(tokenizer_token() != TOKENIZER_CR) ; } // token for the next statement in the pgm tokenizer_next(); } else { // skip over 'then' part of 'if' statement. // need to count brackets for nesting do { tokenizer_next(); if (tokenizer_token() == TOKENIZER_RIGHTBRACK) bracket_depth--; if (tokenizer_token() == TOKENIZER_LEFTBRACK) bracket_depth++; } while(tokenizer_token() != TOKENIZER_RIGHTBRACK || bracket_depth>0) ; // find the else do { tokenizer_next(); } while(tokenizer_token() != TOKENIZER_ELSE && tokenizer_token() != TOKENIZER_CR && tokenizer_token() != TOKENIZER_ENDOFINPUT); if(tokenizer_token() == TOKENIZER_ELSE) { tokenizer_next(); accept(TOKENIZER_LEFTBRACK); statement(); // more than one statement? while(tokenizer_token() != TOKENIZER_RIGHTBRACK) { statement(); } accept(TOKENIZER_RIGHTBRACK); accept(TOKENIZER_CR); } else if(tokenizer_token() == TOKENIZER_CR) { tokenizer_next(); } } } /*---------------------------------------------------------------------------*/ static void let_statement(void) { int var; var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); ubasic_set_variable(var, expr()); DEBUG_PRINTF("let_statement: assign %d to %d\n", variables[var], var); accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ // syntax: peek addr, var // added by brl4 static void peek_statement(void){ char* addr; int var ; accept(TOKENIZER_PEEK); addr = expr() ; accept(TOKENIZER_COMMA); var = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); ubasic_set_variable(var, *addr); accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ // syntax: poke addr, expr // added by brl4 static void poke_statement(void){ short* addr; short val ; accept(TOKENIZER_POKE); addr = expr() ; accept(TOKENIZER_COMMA); val = expr() ; *addr = val ; accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ // syntax: outputA bits, 0/1/-1 clr/set/toggle // added by brl4 static void outputA_statement(void){ int bits ; int val ; accept(TOKENIZER_OUTPUTA); bits = expr() ; mPORTASetPinsDigitalOut(bits); //Set port as output accept(TOKENIZER_COMMA); val = expr() ; //printf("%d %d\n\r", bits, val); if (val==0) mPORTAClearBits(bits); if (val==1) mPORTASetBits(bits); if (val==-1) mPORTAToggleBits(bits); accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ // syntax: delay expr // added by brl4 static void delay_statement(void){ int val, current_time; accept(TOKENIZER_DELAY); val = expr() ; // read pt timer current_time = time_tick_millsec; while (time_tick_millsec < current_time+val){}; accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ /*static void return_statement(void) { accept(TOKENIZER_RETURN); if(gosub_stack_ptr > 0) { gosub_stack_ptr--; jump_linenum(gosub_stack[gosub_stack_ptr]); } else { DEBUG_PRINTF("return_statement: non-matching return\n"); } }*/ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ // modified for {} delimited block -- BRL4 static void for_statement(void) { int for_variable, to, for_value; int* for_ptr; //char accept(TOKENIZER_FOR); for_variable = tokenizer_variable_num(); accept(TOKENIZER_VARIABLE); accept(TOKENIZER_EQ); ubasic_set_variable(for_variable, expr()); accept(TOKENIZER_TO); to = expr(); // record the next token search location for_ptr = tokenizer_ptr() ; while (variables[for_variable]<= to){ tokenizer_next(); statement(); //PT_SPAWN(pt, &pt_statement, protothread_statement(&pt_statement) ); // more than one statement? while(tokenizer_token() != TOKENIZER_RIGHTBRACK) { statement(); //PT_SPAWN(pt, &pt_statement, protothread_statement(&pt_statement) ); } //variables[for_variable]++ ; for_value = ubasic_get_variable(for_variable); ubasic_set_variable(for_variable, ++for_value) ; if (variables[for_variable] <= to) tokenizer_ptr_set(for_ptr) ; } tokenizer_next(); accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ // modified for {} delimited block -- BRL4 static void while_statement(void) { int while_expr ; int* while_ptr, end_ptr ; char finished=0, bracket_depth=0 ; accept(TOKENIZER_WHILE); // record the next token search location while_ptr = tokenizer_ptr() ; while_expr = relation(); // record the next pointer after the while loop ends // need to count brackets for nesting bracket_depth = 1; //skip over LEFTBRACK do { tokenizer_next(); if (tokenizer_token() == TOKENIZER_RIGHTBRACK) bracket_depth--; if (tokenizer_token() == TOKENIZER_LEFTBRACK) bracket_depth++; } while(tokenizer_token() != TOKENIZER_RIGHTBRACK || bracket_depth>0) ; end_ptr = tokenizer_ptr() ; // are we finished yet? if (while_expr) { finished = 1 ; tokenizer_ptr_set(while_ptr); relation(); } else { finished = 0; tokenizer_ptr_set(end_ptr); } while (finished){ //printf("%d", tokenizer_token()); accept(TOKENIZER_LEFTBRACK); //tokenizer_next(); statement(); // more than one statement? while(tokenizer_token() != TOKENIZER_RIGHTBRACK) { statement(); } //end_ptr = tokenizer_ptr() ; tokenizer_ptr_set(while_ptr) ; while_expr = relation(); if (!while_expr){ tokenizer_ptr_set(end_ptr) ; finished = 0; } } tokenizer_next(); accept(TOKENIZER_CR); } /*---------------------------------------------------------------------------*/ static void rem_statement(void) { accept(TOKENIZER_REM); //printf("rem"); //while(tokenizer_token() != TOKENIZER_CR){ // tokenizer_next(); //printf("loop "); //} // skip comment with NO parsing while((*(ptr++)) != ';'){ //printf("loop-%c,", (*ptr)); } // expects new pointer in 'nextptr' nextptr = ptr++; tokenizer_next(); } /*---------------------------------------------------------------------------*/ static void end_statement(void) { accept(TOKENIZER_END); ended = 1; } /*---------------------------------------------------------------------------*/ void statement(void) { int token; token = tokenizer_token(); switch(token) { case TOKENIZER_VARIABLE: let_statement(); break; case TOKENIZER_PRINT: print_statement(); break; case TOKENIZER_IF: if_statement(); break; case TOKENIZER_FOR: for_statement(); break; case TOKENIZER_END: end_statement(); break; case TOKENIZER_PEEK: peek_statement(); break; case TOKENIZER_POKE: poke_statement(); break; case TOKENIZER_DELAY: delay_statement(); break; case TOKENIZER_WHILE: while_statement(); break; case TOKENIZER_REM: rem_statement(); break; case TOKENIZER_OUTPUTA: outputA_statement(); break; //case TOKENIZER_LET: // accept(TOKENIZER_LET); // Fall through. default: DEBUG_PRINTF("ubasic.c: statement(): not implemented %d\n", token); exit(1); } } /*---------------------------------------------------------------------------*/ /*static void line_statement(void) { DEBUG_PRINTF("----------- Line number %d ---------\n", tokenizer_num()); /* current_linenum = tokenizer_num();*/ /*accept(TOKENIZER_NUMBER); statement(); return; } */ /*---------------------------------------------------------------------------*/ void ubasic_run(void) { if(tokenizer_finished()) { DEBUG_PRINTF("uBASIC program finished\n"); return; // kill this input thread, to allow spawning thread to execute } statement(); //modified to eliminate line numbers } /*---------------------------------------------------------------------------*/ int ubasic_finished(void) { return ended || tokenizer_finished(); } /*---------------------------------------------------------------------------*/ void ubasic_set_variable(int varnum, int value) { if(varnum >= 0 && varnum <= MAX_VARNUM) { variables[varnum] = value; } } /*---------------------------------------------------------------------------*/ int ubasic_get_variable(int varnum) { if(varnum >= 0 && varnum <= MAX_VARNUM) { return variables[varnum]; } return 0; } /*---------------------------------------------------------------------------*/