redsnow 0.0.8

data/ext/snowcrash/src/ParametersParser.h

@@ -0,0 +1,252 @@
+//
+//  ParametersParser.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 9/1/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_PARAMETERSPARSER_H
+#define SNOWCRASH_PARAMETERSPARSER_H
+
+#include <sstream>
+#include "BlueprintParserCore.h"
+#include "Blueprint.h"
+#include "RegexMatch.h"
+#include "StringUtility.h"
+#include "BlockUtility.h"
+#include "ParameterDefinitonParser.h"
+
+namespace snowcrashconst {
+    
+    /** Parameters matching regex */
+    const char* const ParametersRegex = "^[[:blank:]]*[Pp]arameters?[[:blank:]]*$";
+
+    /** Expected parameters content */
+    const char* const ExpectedParametersContent = "a nested list of parameters, one parameter per list item";
+
+    /** No parameters specified message */
+    const char* const NoParametersMessage = "no parameters specified, expected a nested list of parameters, one parameter per list item";
+}
+
+namespace snowcrash {
+    
+    /** Internal type alias for Collection of Paramaeter */
+    typedef Collection<Parameter>::type ParameterCollection;
+
+    
+    /** Finds a parameter inside a parameters collection */
+    FORCEINLINE ParameterCollection::iterator FindParameter(ParameterCollection& parameters,
+                                                           const Parameter& parameter) {
+        return std::find_if(parameters.begin(),
+                            parameters.end(),
+                            std::bind2nd(MatchName<Parameter>(), parameter));
+    }
+    
+    /**
+     *  Returns true if given block has parameters signature, false otherwise.
+     */
+    FORCEINLINE bool HasParametersSignature(const BlockIterator& begin,
+                                            const BlockIterator& end) {
+
+        if (begin->type != ListBlockBeginType &&
+            begin->type != ListItemBlockBeginType)
+            return false;
+        
+        SourceData remainingContent;
+        SourceData content = GetListItemSignature(begin, end, remainingContent);
+        TrimString(content);
+        return RegexMatch(content, snowcrashconst::ParametersRegex);
+    }
+    
+    /** Children List Block Classifier, ParameterCollection context. */
+    template <>
+    FORCEINLINE SectionType ClassifyChildrenListBlock<ParameterCollection>(const BlockIterator& begin,
+                                                                           const BlockIterator& end){
+        // TODO:
+        return UndefinedSectionType;
+    }
+    
+    /** Block Classifier, ParameterCollection context. */
+    template <>
+    FORCEINLINE SectionType ClassifyBlock<ParameterCollection>(const BlockIterator& begin,
+                                                           const BlockIterator& end,
+                                                           const SectionType& context) {
+        
+        if (context == UndefinedSectionType) {
+            if (HasParametersSignature(begin, end))
+                return ParametersSectionType;
+        }
+        else if (context == ParametersSectionType) {
+            
+            if (begin->type == ListItemBlockEndType ||
+                begin->type == ListBlockEndType)
+                return UndefinedSectionType;
+            
+            if (HasParameterDefinitionSignature(begin, end))
+                return ParameterDefinitionSectionType;
+            
+            if (begin->type == ListBlockBeginType)
+                return ForeignSectionType; // Foreign nested list-item
+            
+            if (begin->type == ListItemBlockBeginType)
+                return UndefinedSectionType;
+        }
+        else if (context == ParameterDefinitionSectionType ||
+                 context == ForeignSectionType) {
+            
+            if (begin->type == ListItemBlockEndType ||
+                begin->type == ListBlockEndType)
+                return UndefinedSectionType;
+            
+            if (HasParameterDefinitionSignature(begin, end))
+                return ParameterDefinitionSectionType;
+            
+            return ForeignSectionType;
+        }
+        
+        return (context == ParametersSectionType) ? context : UndefinedSectionType;
+    }
+
+    /**
+     *  Parameters section parser.
+     */
+    template<>
+    struct SectionParser<ParameterCollection> {
+        
+        static ParseSectionResult ParseSection(const BlueprintSection& section,
+                                               const BlockIterator& cur,
+                                               BlueprintParserCore& parser,
+                                               ParameterCollection& parameters) {
+            
+            ParseSectionResult result = std::make_pair(Result(), cur);
+            switch (section.type) {
+                case ParametersSectionType:
+                    result = HandleParmetersSection(section, cur, parser, parameters);
+                    break;
+                    
+                case ParameterDefinitionSectionType:
+                    result = HandleParmeterDefinitionSection(section, cur, parser, parameters);
+                    break;
+                    
+                case ForeignSectionType:
+                    result = HandleForeignSection<ParameterCollection>(section, cur, parser.sourceData);
+                    break;
+                    
+                case UndefinedSectionType:
+                    result.second = CloseList(cur, section.bounds.second);
+                    break;
+                    
+                default:
+                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
+                    break;
+            }
+            
+            return result;
+        }
+        
+        static void Finalize(const SectionBounds& bounds,
+                             BlueprintParserCore& parser,
+                             ParameterCollection& parameters,
+                             Result& result) {}
+        
+        /**
+         *  \brief  Parse Parameters top-level section blocks.
+         *  \param  section Actual section being parsed.
+         *  \param  cur     The actual position within Markdown block buffer.
+         *  \param  parser  Parser's instance.
+         *  \param  payload An output buffer to write parameters into.
+         *  \return A block parser section result.
+         */
+        static ParseSectionResult HandleParmetersSection(const BlueprintSection& section,
+                                                         const BlockIterator& cur,
+                                                         BlueprintParserCore& parser,
+                                                         ParameterCollection& parameters) {
+            
+            ParseSectionResult result = std::make_pair(Result(), cur);
+            BlockIterator sectionCur = cur;
+            
+            // Signature
+            if (sectionCur == section.bounds.first) {
+                
+                CheckSignatureAdditionalContent(section,
+                                                sectionCur,
+                                                parser.sourceData,
+                                                "'parameters' keyword",
+                                                snowcrashconst::ExpectedParametersContent,
+                                                result.first);
+                result.second = SkipSignatureBlock(sectionCur, section.bounds.second);
+                return result;
+            }
+            
+            // Unexpected description
+            if (sectionCur->type == QuoteBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, QuoteBlockBeginType, QuoteBlockEndType);
+            }
+            else if (sectionCur->type == ListBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListBlockBeginType, ListItemBlockEndType);
+            }
+            
+            if (!CheckCursor(section, sectionCur, parser.sourceData, result.first))
+                return result;
+            
+            // WARN: on ignoring additional content
+            std::stringstream ss;
+            ss << "ignoring additional content in the 'parameters' definition, expected " << snowcrashconst::ExpectedParametersContent;
+            
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, parser.sourceData);
+            result.first.warnings.push_back(Warning(ss.str(),
+                                                    IgnoringWarning,
+                                                    sourceBlock));
+            
+            if (sectionCur != section.bounds.second)
+                result.second = ++sectionCur;
+
+            return result;
+        }
+        
+        /** Parse a parameter definition top-level section blocks. */
+        static ParseSectionResult HandleParmeterDefinitionSection(const BlueprintSection& section,
+                                                                  const BlockIterator& cur,
+                                                                  BlueprintParserCore& parser,
+                                                                  ParameterCollection& parameters) {
+            Parameter parameter;
+            ParseSectionResult result = ParameterDefinitionParser::Parse(cur,
+                                                                         section.bounds.second,
+                                                                         section,
+                                                                         parser,
+                                                                         parameter);
+            if (result.first.error.code != Error::OK)
+                return result;
+
+            // Check duplicates
+            if (!parameters.empty()) {
+                ParameterCollection::iterator duplicate = FindParameter(parameters, parameter);
+                if (duplicate != parameters.end()) {
+
+                    // WARN: Parameter already defined
+                    std::stringstream ss;
+                    ss << "overshadowing previous parameter '" << parameter.name << "' definition";
+
+                    BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
+                    SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
+                    result.first.warnings.push_back(Warning(ss.str(),
+                                                            RedefinitionWarning,
+                                                            sourceBlock));
+                    
+                    // Erase origan duplicate 
+                    parameters.erase(duplicate);
+                }
+            }
+            
+            parameters.push_back(parameter);
+            
+            return result;
+        }
+    };
+    
+    typedef BlockParser<ParameterCollection, SectionParser<ParameterCollection> > ParametersParser;
+}
+
+
+#endif

data/ext/snowcrash/src/Parser.cc

@@ -0,0 +1,71 @@
+//
+//  Parser.cpp
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/8/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <exception>
+#include <sstream>
+#include "Parser.h"
+#include "MarkdownParser.h"
+#include "BlueprintParser.h"
+
+using namespace snowcrash;
+
+const int SourceAnnotation::OK = 0;
+
+// Check source for unsupported character \t & \r
+// Returns true if passed (not found), false otherwise
+static bool CheckSource(const SourceData& source, Result& result)
+{
+    std::string::size_type pos = source.find("\t");
+    if (pos != std::string::npos) {
+        result.error = Error("the use of tab(s) '\\t' in source data isn't currently supported, please contact makers",
+                             2,
+                             MapSourceDataBlock(MakeSourceDataBlock(pos, 1), source));
+        return false;
+    }
+
+    pos = source.find("\r");
+    if (pos != std::string::npos) {
+        result.error = Error("the use of carriage return(s) '\\r' in source data isn't currently supported, please contact makers",
+                             2,
+                             MapSourceDataBlock(MakeSourceDataBlock(pos, 1), source));
+        return false;
+    }
+    
+    return true;
+}
+
+void Parser::parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint)
+{
+    try {
+        
+        // Sanity Check
+        if (!CheckSource(source, result))
+            return;
+        
+        // Parse Markdown
+        MarkdownBlock::Stack markdown;
+        MarkdownParser markdownParser;
+        markdownParser.parse(source, result, markdown);
+        
+        if (result.error.code != Error::OK)
+            return;
+        
+        // Parse Blueprint
+        BlueprintParser::Parse(source, markdown, options, result, blueprint);
+    }
+    catch (const std::exception& e) {
+
+        std::stringstream ss;
+        ss << "parser exception: '" << e.what() << "'";
+        result.error = Error(ss.str(), 1);
+    }
+    catch (...) {
+        
+        result.error = Error("parser exception has occured", 1);
+    }
+}

data/ext/snowcrash/src/Parser.h

@@ -0,0 +1,29 @@
+//
+//  Parser.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/8/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_PARSER_H
+#define SNOWCRASH_PARSER_H
+
+#include <functional>
+#include "Blueprint.h"
+#include "BlueprintParserCore.h"
+
+namespace snowcrash {
+    
+    //
+    // API Blueprint Parser
+    //
+    class Parser {
+    public:
+        
+        // Parse source data into Blueprint AST
+        void parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint);
+    };
+}
+
+#endif

data/ext/snowcrash/src/ParserCore.cc

@@ -0,0 +1,120 @@
+//
+//  ParserCore.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/4/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "ParserCore.h"
+
+using namespace snowcrash;
+
+SourceDataBlock snowcrash::MakeSourceDataBlock(size_t loc, size_t len)
+{
+    SourceDataRange r;
+    r.location = loc;
+    r.length = len;
+    return SourceDataBlock(1, r);
+}
+
+void snowcrash::AppendSourceDataBlock(SourceDataBlock& destination, const SourceDataBlock& append)
+{
+    if (append.empty())
+        return;
+    
+    if (destination.empty() ||
+        append.front().location != destination.back().location + destination.back().length) {
+        destination.insert(destination.end(), append.begin(), append.end());
+    }
+    else {
+        // merge
+        destination.back().length += append.front().length;
+        
+        if (append.size() > 1) {
+            destination.insert(destination.end(), ++append.begin(), append.end());
+        }
+    }
+}
+
+SourceDataBlockPair snowcrash::SplitSourceDataBlock(const SourceDataBlock& block, size_t len)
+{
+    if (block.empty())
+        return std::make_pair(SourceDataBlock(), SourceDataBlock());
+
+    SourceDataBlock first;
+    SourceDataBlock second;
+    
+    size_t remain = len;
+    for (SourceDataBlock::const_iterator it = block.begin(); it != block.end(); ++it) {
+        
+        if (remain == 0) {
+            second.push_back(*it);
+            continue;
+        }
+        
+        if (remain >= it->length) {
+            first.push_back(*it);
+            remain -= it->length;
+            continue;
+        }
+        
+        if (remain < it->length) {
+            SourceDataRange left = *it;
+            left.length = remain;
+            first.push_back(left);
+            
+            SourceDataRange right = *it;
+            right.location += remain;
+            right.length -= remain;
+            second.push_back(right);
+        }
+    }
+    
+    return std::make_pair(first, second);
+}
+
+#define UTF8_CHAR_LEN( byte ) (( 0xE5000000 >> (( byte >> 3 ) & 0x1e )) & 3 ) + 1
+
+/** \returns Number of UTF8 characters in byte buffer */
+static size_t strnlen_utf8(const char* s, size_t len)
+{
+    if (!s || !len)
+        return 0;
+    
+    size_t i = 0, j = 0;
+	while (s[i] && i < len) {
+        i += UTF8_CHAR_LEN(s[i]);
+        j++;
+	}
+	return j;
+}
+
+SourceCharactersRange snowcrash::MapSourceDataRange(const SourceDataRange& range, const SourceData& data)
+{
+    if (data.empty())
+        return SourceCharactersRange();
+    
+    size_t charLocation = 0;
+    if (range.location > 0)
+        charLocation = strnlen_utf8(data.c_str(), range.location);
+    
+    size_t charLength = 0;
+    if (range.length > 0)
+        charLength = strnlen_utf8(data.c_str() + range.location, range.length);
+    
+    SourceCharactersRange characterRange = {charLocation, charLength };
+    return characterRange;
+}
+
+SourceCharactersBlock snowcrash::MapSourceDataBlock(const SourceDataBlock& block, const SourceData& data)
+{
+    SourceCharactersBlock characterMap;
+    
+    for (SourceDataBlock::const_iterator it = block.begin(); it != block.end(); ++it) {
+        SourceCharactersRange characterRange = MapSourceDataRange(*it, data);
+        characterMap.push_back(characterRange);
+    }
+        
+    return characterMap;
+}