clause.cpp

epson usb2.0 控制芯片 S1R72V05 固件程序。

/*
 *  TOPPERS/JSP Kernel
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      Just Standard Profile Kernel
 * 
 *  Copyright (C) 2003 by Embedded and Real-Time Systems Laboratory
 *                              Toyohashi Univ. of Technology, JAPAN
 * 
 *  忋婰挊嶌尃幰偼丆埲壓偺 (1)乣(4) 偺忦審偐丆Free Software Foundation 
 *  偵傛偭偰岞昞偝傟偰偄傞 GNU General Public License 偺 Version 2 偵婰
 *  弎偝傟偰偄傞忦審傪枮偨偡応崌偵尷傝丆杮僜僼僩僂僃傾乮杮僜僼僩僂僃傾
 *  傪夵曄偟偨傕偺傪娷傓丏埲壓摨偠乯傪巊梡丒暋惢丒夵曄丒嵞攝晍乮埲壓丆
 *  棙梡偲屇傇乯偡傞偙偲傪柍彏偱嫋戻偡傞丏
 *  (1) 杮僜僼僩僂僃傾傪僜乕僗僐乕僪偺宍偱棙梡偡傞応崌偵偼丆忋婰偺挊嶌
 *      尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕偑丆偦偺傑傑偺宍偱僜乕
 *      僗僐乕僪拞偵娷傑傟偰偄傞偙偲丏
 *  (2) 杮僜僼僩僂僃傾傪丆儔僀僽儔儕宍幃側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒傞宍偱嵞攝晍偡傞応崌偵偼丆嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡
 *      幰儅僯儏傾儖側偳乯偵丆忋婰偺挊嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰
 *      偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *  (3) 杮僜僼僩僂僃傾傪丆婡婍偵慻傒崬傓側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒側偄宍偱嵞攝晍偡傞応崌偵偼丆師偺偄偢傟偐偺忦審傪枮偨偡偙
 *      偲丏
 *    (a) 嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡幰儅僯儏傾儖側偳乯偵丆忋婰偺挊
 *        嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *    (b) 嵞攝晍偺宍懺傪丆暿偵掕傔傞曽朄偵傛偭偰丆TOPPERS僾儘僕僃僋僩偵
 *        曬崘偡傞偙偲丏
 *  (4) 杮僜僼僩僂僃傾偺棙梡偵傛傝捈愙揑傑偨偼娫愙揑偵惗偠傞偄偐側傞懝
 *      奞偐傜傕丆忋婰挊嶌尃幰偍傛傃TOPPERS僾儘僕僃僋僩傪柶愑偡傞偙偲丏
 * 
 *  杮僜僼僩僂僃傾偼丆柍曐徹偱採嫙偝傟偰偄傞傕偺偱偁傞丏忋婰挊嶌尃幰偍
 *  傛傃TOPPERS僾儘僕僃僋僩偼丆杮僜僼僩僂僃傾偵娭偟偰丆偦偺揔梡壜擻惈傕
 *  娷傔偰丆偄偐側傞曐徹傕峴傢側偄丏傑偨丆杮僜僼僩僂僃傾偺棙梡偵傛傝捈
 *  愙揑傑偨偼娫愙揑偵惗偠偨偄偐側傞懝奞偵娭偟偰傕丆偦偺愑擟傪晧傢側偄丏
 * 
 *  @(#) $Id: clause.cpp,v 1.1 2006/04/14 02:46:01 9564907 Exp $
 */

// $Header: J:\\SapporoSoft\\usb20\\S1R72V05\\Debug\\Repository/S1R72V05_Toppers/Toppers/cfg/base/clause.cpp,v 1.1 2006/04/14 02:46:01 9564907 Exp $

#include "base/clause.h"
#include "base/message.h"

using namespace std;

/*
 *   峔暥忋偺堦愡傪張棟偡傞僋儔僗
 */

    //巜掕偟偨柤慜嬻娫偺愡儅僢僾傪庢摼
Clause::map_type * Clause::getClauseMap(string name) throw()
{
    map_type * result = NULL;
    Namespace::iterator scope;

    Namespace * const ns = Singleton<Namespace>::getInstance(nothrow);
    if(ns!= 0) {
        scope = ns->find(name);
        if(scope != ns->end())
            result = &(scope->second);
    }

    return result;
}

    //愡偺搊榐
void Clause::addClause(string _namespace, string _identifier) throw()
{
    if(isValid()) {
        Namespace * const ns = Singleton<Namespace>::getInstance(nothrow);
        if(ns != 0)
            (*ns)[_namespace][_identifier] = this;
//          ns->operator [](_namespace).insert(map_type::value_type(_identifier, this));        //忋彂偒偝偣側偄応崌
    }
}

    //僩乕僋儞偵懳偟偰愡幆暿柤傪惗惉偡傞
string Clause::getClauseIdentifier(Token token) throw()
{
    string result;

    switch(token.getType()) {
        case Token::IDENTIFIER:
        case Token::PUNCTUATOR:
            result = token.getLiteral();    
            break;
        case Token::INTEGER:
            result.assign(INTEGER_CLAUSE_IDENTIFIER);
            break;
        case Token::LITERAL:
            result.assign(LITERAL_CLAUSE_IDENTIFIER);
            break;
        case Token::OPERATOR:
            result.assign(OPERATOR_CLAUSE_IDENTIFIER);
            break;
        default:
            result = string();
    }

    return result;
}

    //愡偺夝愅
bool Clause::parseClause(string ns, Parser & p)
{
    bool result = false;
    map_type::iterator scope;
    map_type * clause = getClauseMap(ns);

        //僈乕僪愡
    if(clause == 0 || p.eof())
        return false;

        //僩乕僋儞偐傜幆暿柤傪庢傝弌偡
    Token  token;
    string identifier;

    token      = p.getToken();
    identifier = getClauseIdentifier(token);
    
        //愡張棟晹偺幚峴
    scope = clause->find(identifier);
    if(scope != clause->end()) {

            //僨僶僢僌梡儊僢僙乕僕弌椡
        DebugMessage("Clause::parseClause(%) - %\n") << ns << identifier;

        try {
            scope->second->before(token, p);
            scope->second->body(token, p);  //僸僢僩偟偨傕偺傪幚峴
            scope->second->after(token, p);
            result = true;
        }
        catch(...) {
            scope->second->onFail(token, p);    //幐攕偟偨偲偒偺屻巒枛傪偍婅偄偡傞
            throw;
        }
    }
    else
        p.putback(token);   //幆暿巕偵儅僢僠偡傞傕偺偑搊榐偝傟偰偄側偄

    return result;
}

    //first偱巒傑傞愡偑偁傞偐
bool Clause::hasClause(string ns, string first) throw()
{
    map_type * clause = getClauseMap(ns);
    if(clause == 0)
        return false;

    return clause->find(first) != clause->end();
}

    //僷乕僗慜張棟
void Clause::before(const Token &, Parser &)
{}

    //僷乕僗屻張棟
void Clause::after(const Token &, Parser &)
{}

    //昗弨偺椺奜敪惗帪偺屻巒枛儖乕僠儞
void Clause::onFail(const Token &, Parser & p) throw()
{
    Token token;

        //嵟屻傑偱撉傒偒傞
    while(!p.eof())
        token = p.getToken();
}

    //愡傪暋悢偺幆暿柤偵懳墳晅偗傞
void Clause::addMultipleClauses(string ns, string id_list) throw()
{
    string            id;
    string::size_type pos;
    string::size_type prev;

        //僇儞儅偱嬫愗傜傟偨梫慺枅偵addClause傪敪峴
    if(isValid()) {
        prev = 0;
        do {
            pos = id_list.find_first_of(',', prev);
            id  = id_list.substr(prev, pos - prev);

            addClause(ns, id);

            prev = pos + 1;
        } while(pos != string::npos);
    }
}

    //[僿儖僾梡] 搊榐偝傟偰偄傞愡偺堦棗傪嶌惉偡傞
std::string Clause::makeClauseList(string ns, int width) throw()
{
    string result;
    map_type::iterator scope;
    map_type * clause = getClauseMap(ns);
    size_t max_length = 0;

        //嵟戝偺暥帤楍挿傪媮傔傞
    scope = clause->begin();
    while(scope != clause->end()) {
        size_t i = scope->first.size();
        if(i > max_length)
            max_length = i;
        ++ scope;
    }

        //堦棗傪嶌惉
    size_t max_column = width/(max_length+1);
    size_t column = 0;
    scope = clause->begin();
    while(scope != clause->end()) {
        size_t i = scope->first.size();

        result += scope->first;

        ++ column;
        ++ scope;

            //枛旜張棟
        if(column == max_column || scope == clause->end())
            result += '\n';
        else {
            result += ',';
            result += string(max_length - i, ' ');
        }
    }

    return result;
}


    /*
     *   惷揑API
     */

    //僷乕僗慜張棟
void StaticAPI::before(const Token & first, Parser & p)
{
    Token token = p.getToken();
    if(token != Token::LPAREN) {
        ExceptionMessage("StaticAPI [%] lacks left-parenthesis '('.","惷揑API[%]偵偼妵屖'('偑寚偗偰偄傞") << first.getLiteral() << throwException;
    }
}

    //僷乕僗屻張棟
void StaticAPI::after(const Token & first, Parser & p)
{
    Token token = p.getToken();
    if(token != Token::RPAREN) {
        ExceptionMessage("StaticAPI [%] lacks right-parenthesis ')'.","惷揑API[%]偵偼妵屖')'偑寚偗偰偄傞") << first.getLiteral() << throwException;
    }
    else {
        token = p.getToken();
        if(token != ";")
            ExceptionMessage("StaticAPI [%] lacks ';' at the end of declaration.","惷揑API[%]偺枛旜偵';'偑寚偗偰偄傞") << first.getLiteral() << throwException;
    }
}

    //幐攕帪偺夞暅張棟
void StaticAPI::onFail(const Token & , Parser & p) throw()
{   skip(p, false);   }


    //僗僉僢僾
    //   invalid_api : 師偵嵟弶偵撉傒弌偝傟傞API偼柍岠
void StaticAPI::skip(Parser & p, bool invalid_api) throw()
{
        //僙儈僐儘儞 or 師偺惷揑API偺弌尰傑偱
    Token token;
    bool  condition; //傾儗懳嶔

    if(invalid_api)
        token = p.getToken();   //師偺API柤偼撉傒旘偽偡

    do {
        token = p.getToken(true);

        condition = (!token.isValid()) ||                                                   //柍岠側僩乕僋儞偐
                    (token == Token::PUNCTUATOR && token == ";") ||                         //僙儈僐儘儞偐
                    (token == Token::IDENTIFIER && hasStaticAPI(token.getLiteral()));       //惷揑API偐

    } while(!condition);

    if(token == Token::IDENTIFIER)
        p.putback(token);
}

    /*
     *   僾儕僾儘僙僗僨傿儗僋僥傿僽
     */

    //僷乕僗屻張棟
void Directives::after(const Token & first, Parser & p) throw(Exception)
{
    Token token = p.getToken(true);
    if(!token.isValid() || !p.isLocatedonHeadofLine())
        ExceptionMessage("Directive [%] has a wrong parameter or misses a new-line.","僨傿儗僋僥傿僽[%]偵晄惓側堷悢偑偁傞偐丄夵峴偑側偄") << first.getLiteral() << throwException;
}

    //僷乕僗幐攕帪偺夞暅張棟
void Directives::onFail(const Token & , Parser & p) throw()
{
        //師偺夵峴傑偱撉傒旘偽偡
    Token token;

    do {
        token = p.getToken(true);
    } while(token.isValid() && !p.isLocatedonHeadofLine());
}

/************************************************* 僥僗僩僗傿乕僩 *************************************************/