pic14.h

/***************************************************************************
 *   Copyright (C) 2004-2005 by Daniel Clarke                              *
 *   daniel.jc@gmail.com                                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef PIC14_H
#define PIC14_H

#include "expression.h"
#include "microbe.h"

#include <qstring.h>
#include <qstringlist.h>
#include <qvaluelist.h>

class Code;
class Microbe;
class Parser;

class PortPin
{
        public:
                PortPin( const QString & port, int pin );
                PortPin();
                QString port() const { return m_port; }
                int portPosition() const;
                int pin() const { return m_pin; }
                
        protected:
                QString m_port;
                int m_pin;
};
typedef QValueList<PortPin> PortPinList;


class PIC14
{
        public:
                enum Type
                {
                        P16C84,
                        P16F84,
                        P16F627,
                        P16F628,
                        unknown,
                };
                enum LocationType
                {
                        num = 1,
                        work = 2,
                        var = 3,
                };
                enum DelaySubroutine
                {
                        Delay_None      = 0,
                        Delay_3uS       = 1,
                        Delay_768uS     = 2,
                        Delay_200mS     = 3,
                        Delay_50S       = 4,
                };
                
                PIC14( Microbe * master, Type type );
                ~PIC14();
                
                static Type toType( const QString & text );
                Type type() const { return m_type; }
                QString minimalTypeString() const;
                PortPin toPortPin( const QString & portPinString );
                uchar gprStart() const;
                
                void setParser(Parser *parser) { m_parser = parser; }
                void setCode( Code * code ) { m_pCode = code; }
                void mergeCode( Code * code );
        
                void setConditionalCode( Code * ifCode, Code * elseCode );
                Code * ifCode();
                Code * elseCode();
        
                Code * m_ifCode;
                Code * m_elseCode;

                void postCompileConstruct( const QStringList &interrupts );

                bool isValidPort( const QString & portName ) const;
                bool isValidPortPin( const PortPin & portPin ) const;
                bool isValidTris( const QString & trisName ) const;
                bool isValidInterrupt( const QString & interruptName ) const;

                void Sgoto(const QString &label);
                void Slabel(const QString &label);
                void Send();
                void Ssubroutine(const QString &procName, Code * compiledProcCode);
                void Sinterrupt(const QString & procName, Code * compiledProcCode);
                void Scall(const QString &name);
        
                void Ssetlh( const PortPin & portPin, bool high);
        
                void add( QString val1, QString val2, LocationType val1Type, LocationType val2Type );
                void subtract( const QString & val1, const QString & val2, LocationType val1Type, LocationType val2Type );
                void mul( QString val1, QString val2, LocationType val1Type, LocationType val2Type);
                void div( const QString & val1, const QString & val2, LocationType val1Type, LocationType val2Type);
        
                void assignNum(const QString & val);
                void assignVar(const QString & val);
        
                void saveToReg(const QString &dest);
                void saveResultToVar( const QString & var );
                void equal( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
                void notEqual( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
                void greaterThan( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
                void lessThan( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
                void greaterOrEqual( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
                void lessOrEqual( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );

                void bitwise( Expression::Operation op, const QString &val1, const QString &val2, bool val1IsNum, bool val2IsNum );
        
                void Swhile( Code * whileCode, const QString &expression);
                void Srepeat( Code * repeatCode, const QString &expression);
                void Sif( Code * ifCode, Code * elseCode, const QString &expression);
                void Sfor( Code * forCode, Code * initCode, const QString &expression, const QString &variable, const QString &step, bool stepPositive);
        
                void Spin( const PortPin & portPin, bool NOT);
                void addCommonFunctions( DelaySubroutine delay );
        
                //BEGIN "Special Functionality" functions
                void Sdelay( unsigned length_us, Code::InstructionPosition pos = Code::Middle );
                void SsevenSegment( const Variable & pinMap );
                void Skeypad( const Variable & pinMap );
                //END "Special Functionality" functions
        
                void SincVar( const QString &var );
                void SdecVar( const QString &var );
                void SrotlVar( const QString &var );
                void SrotrVar( const QString &var );
        
                void Stristate( const QString &port );
        
                void Sasm(const QString &raw);
        
        protected:
                void multiply();
                void divide();
        
                Type m_type;
        
                Parser * m_parser;
                Microbe * mb;
                Code * m_pCode;
        
                void ifInitCode( const QString &val1, const QString &val2, LocationType val1Type, LocationType val2Type );
        
                void rearrangeOpArguments( QString * val1, QString * val2, LocationType * val1Type, LocationType * val2Type);
        
                int interruptNameToBit(const QString &name, bool flag);
};

#endif

---