path: root/library/cpp/uri/parse.h

#pragma once

// #define DO_PRN

#include <cstddef>

#include "common.h"

#include <library/cpp/charset/doccodes.h>
#include <util/generic/strbuf.h>
#include <util/stream/output.h>
#include <util/string/cast.h>
#include <util/system/yassert.h>

namespace NUri {
    class TParser; 

    namespace NParse { 
        class TRange { 
        public: 
            const char* Beg; 
            ui64 FlagsEncodeMasked; 
            ui64 FlagsAllPlaintext; 
            ui32 Encode; 
            ui32 Decode; 

        public: 
            TRange(const char* beg = nullptr) 
                : Beg(beg) 
                , FlagsEncodeMasked(0) 
                , FlagsAllPlaintext(0) 
                , Encode(0) 
                , Decode(0) 
            { 
            } 

            void Reset(const char* beg = nullptr) { 
                *this = TRange(beg); 
            } 

            void AddRange(const TRange& range, ui64 mask); 

            void AddFlag(const char* ptr, ui64 mask, ui64 flag) { 
                if (0 != flag) 
                    AddFlagImpl(ptr, mask, flag, flag); 
            } 

            void AddFlagExcept(const char* ptr, ui64 mask, ui64 flag, ui64 exclflag) { 
                if (0 != flag) 
                    AddFlagImpl(ptr, mask, flag & ~exclflag, flag); 
            } 

            void AddFlagUnless(const char* ptr, ui64 mask, ui64 flag, ui64 exclmask) { 
                if (0 != flag) 
                    AddFlagImpl(ptr, mask, flag, flag, exclmask); 
            } 

            void AddFlag(const char* ptr, ui64 mask, ui64 flag, ui64 exclflag, ui64 exclmask) { 
                if (0 != flag) 
                    AddFlagImpl(ptr, mask, flag & ~exclflag, flag, exclmask); 
            } 

        private: 
            void AddFlagImpl(const char* ptr, ui64 mask, ui64 plainflag, ui64 encflag) { 
                AddFlagAllPlaintextImpl(ptr, plainflag); 
                AddFlagEncodeMaskedImpl(encflag & mask); 
            } 

            void AddFlagImpl(const char* ptr, ui64 mask, ui64 plainflag, ui64 encflag, ui64 exclmask) { 
                AddFlagAllPlaintextImpl(ptr, plainflag); 
                if (0 == (mask & exclmask)) 
                    AddFlagEncodeMaskedImpl(encflag & mask); 
            } 

            void AddFlagAllPlaintextImpl(const char* ptr, ui64 flag) { 
                if (nullptr == Beg) 
                    Beg = ptr; 
                FlagsAllPlaintext |= flag; 
            } 

            void AddFlagEncodeMaskedImpl(ui64 flag) { 
                if (0 == flag) 
                    return; 
                FlagsEncodeMasked |= flag; 
                if (flag & TFeature::FeaturesMaybeEncode) 
                    ++Encode; 
                else if (flag & TFeature::FeaturesDecode) 
                    ++Decode; 
            } 
        }; 

    }

    class TSection 
       : protected  NParse::TRange { 
    private: 
        friend class TParser; 

    private: 
        const char* End; 

        TSection(const char* beg = nullptr) 
            : NParse::TRange(beg) 
            , End(nullptr) 
        { 
        } 

        void Reset() { 
            Enter(nullptr); 
        } 

        void Reset(const char* pc) { 
            Y_ASSERT(!Beg || !pc || Beg < pc); 
            Reset(); 
        } 

        void Enter(const char* pc) { 
            *this = TSection(pc); 
        } 

        bool Leave(const char* pc) { 
            Y_ASSERT(Beg); 
            End = pc; 
            return true; 
        } 

        void Set(const TStringBuf& buf) { 
            Enter(buf.data()); 
            Leave(buf.data() + buf.length()); 
        } 

    public: 
        bool IsSet() const { 
            return End; 
        } 

        TStringBuf Get() const { 
            return TStringBuf(Beg, End); 
        } 

        size_t Len() const { 
            return End - Beg; 
        } 

        size_t DecodedLen() const { 
            return Len() - 2 * Decode; 
        } 

        size_t EncodedLen() const { 
            return 2 * Encode + DecodedLen(); 
        } 

        ui32 GetEncode() const { 
            return Encode; 
        } 

        ui32 GetDecode() const { 
            return Decode; 
        } 

        ui64 GetFlagsEncode() const { 
            return FlagsEncodeMasked; 
        } 

        ui64 GetFlagsAllPlaintext() const { 
            return FlagsAllPlaintext; 
        } 
    }; 

    class TParser { 
    public: 
        TSection Sections[TField::FieldUrlMAX]; 
        TScheme::EKind Scheme; 
        const TParseFlags Flags; 
        const TStringBuf UriStr; 
        TState::EParsed State; 
        ECharset Enc; 

    public: 
        TParser(const TParseFlags& flags, const TStringBuf& uri, ECharset enc = CODES_UTF8) 
            : Scheme(TScheme::SchemeEmpty) 
            , Flags(flags | TFeature::FeatureDecodeANY) 
            , UriStr(uri) 
            , State(TState::ParsedEmpty) 
            , Enc(enc) 
            , HexValue(0) 
            , PctBegin(nullptr) 
        { 
            Y_ASSERT(0 == (Flags & TFeature::FeaturePathOperation) 
                     // can't define all of them 
                     || TFeature::FeaturesPath != (Flags & TFeature::FeaturesPath)); 
            State = ParseImpl(); 
        } 

    public: 
        const TSection& Get(TField::EField fld) const { 
            return Sections[fld]; 
        } 
        TSection& GetMutable(TField::EField fld) { 
            return Sections[fld]; 
        } 
        bool Has(TField::EField fld) const { 
            return Get(fld).IsSet(); 
        } 
        bool IsNetPath() const { 
            return Has(TField::FieldHost) && 2 < UriStr.length() && '/' == UriStr[0] && '/' == UriStr[1]; 
        } 
        bool IsRootless() const { 
            return Has(TField::FieldScheme) && !Has(TField::FieldHost) && (!Has(TField::FieldPath) || '/' != Get(TField::FieldPath).Get()[0]); 
        } 
        // for RFC 2396 compatibility 
        bool IsOpaque() const { 
            return IsRootless(); 
        } 
        static ui64 GetFieldFlags(TField::EField fld, const TParseFlags& flags) { 
            return FieldFlags[fld] & flags; 
        } 
        ui64 GetFieldFlags(TField::EField fld) const { 
            return GetFieldFlags(fld, Flags); 
        } 

    protected: 
        static const TParseFlags FieldFlags[TField::FieldUrlMAX]; 
        TSection::TRange CurRange; 
        unsigned HexValue; 
        const char* PctBegin; 

#ifdef DO_PRN
        IOutputStream& PrintAddr(const char* ptr) const { 
            return Cdbg << "[" << IntToString<16>(ui64(ptr)) << "] "; 
        } 

        IOutputStream& PrintHead(const char* ptr, const char* func) const { 
            return PrintAddr(ptr) << func << " "; 
        } 

        IOutputStream& PrintHead(const char* ptr, const char* func, const TField::EField& fld) const { 
            return PrintHead(ptr, func) << fld; 
        } 

        IOutputStream& PrintTail(const TStringBuf& val) const { 
            return Cdbg << " [" << val << "]" << Endl; 
        } 
        IOutputStream& PrintTail(const char* beg, const char* end) const { 
            return PrintTail(TStringBuf(beg, end)); 
        } 
#endif

        void ResetSection(TField::EField fld, const char* pc = nullptr) { 
#ifdef DO_PRN
            PrintHead(pc, __FUNCTION__, fld); 
            PrintTail(pc); 
#endif
            Sections[fld].Reset(pc); 
        } 

        void storeSection(const TStringBuf& val, TField::EField fld) { 
#ifdef DO_PRN
            PrintHead(val.data(), __FUNCTION__, fld); 
            PrintTail(val); 
#endif
            Sections[fld].Set(val); 
        } 

        void startSection(const char* pc, TField::EField fld) { 
#ifdef DO_PRN
            PrintHead(pc, __FUNCTION__, fld); 
            PrintTail(pc); 
#endif
            copyRequirements(pc); 
            Sections[fld].Enter(pc); 
        } 

        void finishSection(const char* pc, TField::EField fld) { 
#ifdef DO_PRN
            PrintHead(pc, __FUNCTION__, fld); 
            PrintTail(pc); 
#endif
            if (Sections[fld].Leave(pc)) 
                copyRequirements(pc); 
        } 

        void setRequirement(const char* ptr, ui64 flags) { 
#ifdef DO_PRN
            PrintHead(ptr, __FUNCTION__) << IntToString<16>(flags) 
                                         << " & mask=" << IntToString<16>(Flags.Allow | Flags.Extra); 
            PrintTail(ptr); 
#endif
            CurRange.AddFlag(ptr, Flags.Allow | Flags.Extra, flags); 
        } 

        void setRequirementExcept(const char* ptr, ui64 flags, ui64 exclflag) { 
#ifdef DO_PRN
            PrintHead(ptr, __FUNCTION__) << IntToString<16>(flags) 
                                         << " & exclflag=" << IntToString<16>(exclflag) 
                                         << " & mask=" << IntToString<16>(Flags.Allow | Flags.Extra); 
            PrintTail(ptr); 
#endif
            CurRange.AddFlagExcept(ptr, Flags.Allow | Flags.Extra, flags, exclflag); 
        } 

        void setRequirementUnless(const char* ptr, ui64 flags, ui64 exclmask) { 
#ifdef DO_PRN
            PrintHead(ptr, __FUNCTION__) << IntToString<16>(flags) 
                                         << " & exclmask=" << IntToString<16>(exclmask) 
                                         << " & mask=" << IntToString<16>(Flags.Allow | Flags.Extra); 
            PrintTail(ptr); 
#endif
            CurRange.AddFlagUnless(ptr, Flags.Allow | Flags.Extra, flags, exclmask); 
        } 

        void copyRequirementsImpl(const char* ptr); 
        void copyRequirements(const char* ptr) { 
            PctEnd(ptr); 
            if (nullptr != CurRange.Beg && CurRange.Beg != ptr) 
                copyRequirementsImpl(ptr); 
        } 

        void HexDigit(const char* ptr, char c) { 
            Y_UNUSED(ptr); 
            HexAdd(c - '0'); 
        } 
        void HexUpper(const char* ptr, char c) { 
            setRequirementUnless(ptr, TFeature::FeatureToLower, TFeature::FeatureUpperEncoded); 
            HexAdd(c - 'A' + 10); 
        } 
        void HexLower(const char* ptr, char c) { 
            setRequirement(ptr, TFeature::FeatureUpperEncoded); 
            HexAdd(c - 'a' + 10); 
        } 
        void HexAdd(unsigned val) { 
            HexValue <<= 4; 
            HexValue += val; 
        } 
        void HexReset() { 
            HexValue = 0; 
        } 
        void HexSet(const char* ptr); 

        void PctEndImpl(const char* ptr); 
        void PctEnd(const char* ptr) { 
            if (nullptr != PctBegin && ptr != PctBegin) 
                PctEndImpl(ptr); 
        } 
        void PctBeg(const char* ptr) { 
            PctEnd(ptr); 
            HexReset(); 
            PctBegin = ptr; 
        } 

        void checkSectionCollision(TField::EField fld1, TField::EField fld2) { 
            if (Sections[fld1].IsSet() && Sections[fld2].IsSet() && Sections[fld1].Beg == Sections[fld2].Beg) { 
                Sections[fld1].Reset(); 
            } 
        }

        bool doParse(const char* str_beg, size_t length); 
        TState::EParsed ParseImpl(); 
    }; 

}