redsnow 0.0.8

data/ext/snowcrash/src/Version.h

@@ -0,0 +1,39 @@
+//
+//  version.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/14/14.
+//
+//  Attribution Notice:
+//  This work might use parts of Node.js `node_version.h`
+//  https://github.com/joyent/node
+//
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_VERSION_H
+#define SNOWCRASH_VERSION_H
+
+#define SNOWCRASH_MAJOR_VERSION 0
+#define SNOWCRASH_MINOR_VERSION 12
+#define SNOWCRASH_PATCH_VERSION 0
+
+#define SNOWCRASH_VERSION_IS_RELEASE 1
+
+#ifndef SNOWCRASH_STRINGIFY
+#   define SNOWCRASH_STRINGIFY(n) SNOWCRASH_STRINGIFY_HELPER(n)
+#   define SNOWCRASH_STRINGIFY_HELPER(n) #n
+#endif
+
+#define SNOWCRASH_VERSION_STRING_HELPER "v" \
+                                        SNOWCRASH_STRINGIFY(SNOWCRASH_MAJOR_VERSION) "." \
+                                        SNOWCRASH_STRINGIFY(SNOWCRASH_MINOR_VERSION) "." \
+                                        SNOWCRASH_STRINGIFY(SNOWCRASH_PATCH_VERSION)
+
+#if SNOWCRASH_VERSION_IS_RELEASE
+#   define SNOWCRASH_VERSION_STRING SNOWCRASH_VERSION_STRING_HELPER
+#else
+#   define SNOWCRASH_VERSION_STRING SNOWCRASH_VERSION_STRING_HELPER "-pre"
+#endif
+
+#endif

data/ext/snowcrash/src/csnowcrash.cc

@@ -0,0 +1,23 @@
+//
+//  CSnowcrash.cc
+//  snowcrash
+//
+//  Created by Ali Khoramshahi on 13/6/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+#include "csnowcrash.h"
+#include "snowcrash.h"
+
+
+int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_result_t** result, sc_blueprint_t** blueprint)
+{
+    snowcrash::Result* t_result = ::new snowcrash::Result;
+    snowcrash::Blueprint* t_blueprint = ::new snowcrash::Blueprint;
+
+    int ret = snowcrash::parse(source, option, *t_result, *t_blueprint);
+
+    *blueprint = AS_TYPE(sc_blueprint_t, t_blueprint);
+    *result = AS_TYPE(sc_result_t, t_result);
+
+    return ret;
+}

data/ext/snowcrash/src/csnowcrash.h

@@ -0,0 +1,38 @@
+//
+//  CSnowcrash.h
+//  snowcrash
+//  C Implementation of Snowcrash.h for binding purposes
+//
+//  Created by Ali Khoramshahi on 13/6/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SC_C_SNOWCRASH_H
+#define SC_C_SNOWCRASH_H
+
+#include "CSourceAnnotation.h"
+#include "CBlueprint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     *  \This is C interface for snowcrash parser.
+     *
+     *  \param source        A textual source data to be parsed.
+     *  \param options       Parser options. Use 0 for no addtional options.
+     *  \param result        returns the pointer to result report.
+     *  \param blueprint     returns the pointer to blueprint AST.
+     *
+     *  \return Error status code. Zero represents success, non-zero a failure.
+     *
+     *  \this function will allocate `result` and `bluepring`, for deallocation `sc_blueprint_free` and `sc_result_free` should be called.
+     */
+    SC_API int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_result_t** result, sc_blueprint_t** blueprint);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/snowcrash/src/posix/RegexMatch.cc

@@ -0,0 +1,99 @@
+//
+//  RegexMatch.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <regex.h>
+#include <cstring>
+#include "RegexMatch.h"
+
+// FIXME: Migrate to C++11.
+// Naive implementation of regex matching using POSIX regex
+bool snowcrash::RegexMatch(const std::string& target, const std::string& expression)
+{
+    if (target.empty() || expression.empty())
+        return false;
+
+    regex_t regex;
+    int reti = ::regcomp(&regex, expression.c_str(), REG_EXTENDED | REG_NOSUB);
+    if (reti) {
+        // Unable to compile regex
+        return false;
+    }
+    
+    // Execute regular expression
+    reti = ::regexec(&regex, target.c_str(), 0, NULL, 0);
+    if (!reti) {
+        ::regfree(&regex);
+        return true;
+    }
+    else if (reti == REG_NOMATCH) {
+        ::regfree(&regex);
+        return false;
+    }
+    else {
+        char msgbuf[1024];
+        regerror(reti, &regex, msgbuf, sizeof(msgbuf));
+        ::regfree(&regex);
+        return false;
+    }
+    
+    return false;
+}
+
+std::string snowcrash::RegexCaptureFirst(const std::string& target, const std::string& expression)
+{
+    CaptureGroups groups;
+    if (!RegexCapture(target, expression, groups) ||
+        groups.size() < 2)
+        return std::string();
+    
+    return groups[1];
+}
+
+bool snowcrash::RegexCapture(const std::string& target, const std::string& expression, CaptureGroups& captureGroups, size_t groupSize)
+{
+    if (target.empty() || expression.empty())
+        return false;
+    
+    captureGroups.clear();
+    
+    try {
+        regex_t regex;
+        int reti = ::regcomp(&regex, expression.c_str(), REG_EXTENDED);
+        if (reti)
+            return false;
+        
+        regmatch_t *pmatch = ::new regmatch_t[groupSize];
+        ::memset(pmatch, 0, sizeof(regmatch_t) * groupSize);
+        
+        reti = ::regexec(&regex, target.c_str(), groupSize, pmatch, 0);
+        if (!reti) {
+            ::regfree(&regex);
+            
+            for (size_t i = 0; i < groupSize; ++i) {
+                if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
+                    captureGroups.push_back(std::string());
+                else
+                    captureGroups.push_back(std::string(target, pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so));
+            }
+            
+            delete [] pmatch;
+            return true;
+        }
+        else {
+            ::regfree(&regex);
+            delete [] pmatch;        
+            return false;
+        }
+    }
+    catch (...) {
+    }
+    
+    return false;    
+}
+
+

data/ext/snowcrash/src/snowcrash.cc

@@ -0,0 +1,18 @@
+//
+//  snowcrash.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "snowcrash.h"
+
+using namespace snowcrash;
+
+int snowcrash::parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint)
+{
+    Parser p;
+    p.parse(source, options, result, blueprint);
+    return result.error.code;
+}

data/ext/snowcrash/src/snowcrash.h

@@ -0,0 +1,41 @@
+//
+//  snowcrash.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_H
+#define SNOWCRASH_H
+
+#include "Parser.h"
+
+/**
+ *  API Blueprint Parser Interface
+ *  ------------------------------
+ *
+ *  This is the parser's entry point.
+ *
+ *  For Snow Crash users, this is the only interface to use.
+ *
+ *  For binding writers, this is the point to start wrapping.
+ *  Refer to https://github.com/apiaryio/snowcrash/wiki/Writing-a-binding 
+ *  for details on how to write a Snow Crash binding.
+ */
+
+namespace snowcrash {
+    
+    /**
+     *  \brief Parse the source data into a blueprint abstract source tree (AST).
+     *
+     *  \param source        A textual source data to be parsed.
+     *  \param options       Parser options. Use 0 for no addtional options.
+     *  \param result        Parsing result report.
+     *  \param blueprint     Parsed blueprint AST.
+     *  \return Error status code. Zero represents success, non-zero a failure.
+     */
+    int parse(const SourceData& source, BlueprintParserOptions options, Result& result, Blueprint& blueprint);
+}
+
+#endif

data/ext/snowcrash/src/snowcrash/snowcrash.cc

@@ -0,0 +1,170 @@
+//
+//  snowcrash.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/27/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include "snowcrash.h"
+#include "SerializeJSON.h"
+#include "SerializeYAML.h"
+#include "cmdline.h"
+#include "Version.h"
+
+using snowcrash::SourceAnnotation;
+using snowcrash::Error;
+
+static const std::string OutputArgument = "output";
+static const std::string FormatArgument = "format";
+static const std::string RenderArgument = "render";
+static const std::string ValidateArgument = "validate";
+static const std::string VersionArgument = "version";
+
+/// \enum Snow Crash AST output format.
+enum SerializationFormat {
+    YAMLSerializationFormat,
+    JSONSerializationFormat
+};
+
+/// \brief Print Markdown source annotation.
+/// \param prefix A string prefix for the annotation
+/// \param annotation An annotation to print
+void PrintAnnotation(const std::string& prefix, const snowcrash::SourceAnnotation& annotation)
+{
+    std::cerr << prefix;
+    
+    if (annotation.code != SourceAnnotation::OK) {
+        std::cerr << " (" << annotation.code << ") ";
+    }
+    
+    if (!annotation.message.empty()) {
+        std::cerr << " " << annotation.message;
+    }
+    
+    if (!annotation.location.empty()) {
+        for (snowcrash::SourceCharactersBlock::const_iterator it = annotation.location.begin();
+             it != annotation.location.end();
+             ++it) {
+            std::cerr << ((it == annotation.location.begin()) ? " :" : ";");
+            std::cerr << it->location << ":" << it->length;
+        }
+    }
+    
+    std::cerr << std::endl;
+}
+
+/// \brief Print parser result to stderr.
+/// \param result A parser result to print
+void PrintResult(const snowcrash::Result& result)
+{
+    std::cerr << std::endl;
+    
+    if (result.error.code == Error::OK) {
+        std::cerr << "OK.\n";
+    }
+    else {
+        PrintAnnotation("error:", result.error);
+    }
+    
+    for (snowcrash::Warnings::const_iterator it = result.warnings.begin(); it != result.warnings.end(); ++it) {
+        PrintAnnotation("warning:", *it);
+    }
+}
+
+int main(int argc, const char *argv[])
+{
+    cmdline::parser argumentParser;
+
+    argumentParser.set_program_name("snowcrash");
+    std::stringstream ss;
+    ss << "<input file>\n\n";
+    ss << "API Blueprint Parser\n";
+    ss << "If called without <input file>, 'snowcrash' will listen on stdin.\n";
+    argumentParser.footer(ss.str());
+
+    argumentParser.add<std::string>(OutputArgument, 'o', "save output AST into file", false);
+    argumentParser.add<std::string>(FormatArgument, 'f', "output AST format", false, "yaml", cmdline::oneof<std::string>("yaml", "json"));
+    // TODO: argumentParser.add("render", 'r', "render markdown descriptions");
+    argumentParser.add("help", 'h', "display this help message");
+    argumentParser.add(VersionArgument, 'v', "print Snow Crash version");
+    argumentParser.add(ValidateArgument, 'l', "validate input only, do not print AST");
+    
+    argumentParser.parse_check(argc, argv);
+    
+    // Check arguments
+    if (argumentParser.rest().size() > 1) {
+        std::cerr << "one input file expected, got " << argumentParser.rest().size() << std::endl;
+        exit(EXIT_FAILURE);
+    }
+    
+    // Version query
+    if (argumentParser.exist(VersionArgument)) {
+        std::cout << SNOWCRASH_VERSION_STRING << std::endl;
+        exit(EXIT_SUCCESS);
+    }
+
+    // Input
+    std::stringstream inputStream;
+    if (argumentParser.rest().empty()) {
+        // Read stdin
+        inputStream << std::cin.rdbuf();
+    }
+    else {
+        // Read from file
+        std::ifstream inputFileStream;
+        std::string inputFileName = argumentParser.rest().front();
+        inputFileStream.open(inputFileName.c_str());
+        if (!inputFileStream.is_open()) {
+            std::cerr << "fatal: unable to open input file '" << inputFileName << "'\n";
+            exit(EXIT_FAILURE);
+        }
+        
+        inputStream << inputFileStream.rdbuf();
+        inputFileStream.close();
+    }
+
+    // Parse
+    snowcrash::BlueprintParserOptions options = 0;  // Or snowcrash::RequireBlueprintNameOption
+    snowcrash::Result result;
+    snowcrash::Blueprint blueprint;
+    snowcrash::parse(inputStream.str(), options, result, blueprint);
+    
+    // Output
+    if (!argumentParser.exist(ValidateArgument)) {
+        
+        std::stringstream outputStream;
+
+        if (argumentParser.get<std::string>(FormatArgument) == "json") {
+            SerializeJSON(blueprint, outputStream);
+        }
+        else if (argumentParser.get<std::string>(FormatArgument) == "yaml") {
+            SerializeYAML(blueprint, outputStream);
+        }
+        
+        std::string outputFileName = argumentParser.get<std::string>(OutputArgument);
+        if (!outputFileName.empty()) {
+            // Serialize to file
+            std::ofstream outputFileStream;
+            outputFileStream.open(outputFileName.c_str());
+            if (!outputFileStream.is_open()) {
+                std::cerr << "fatal: unable to write to file '" <<  outputFileName << "'\n";
+                exit(EXIT_FAILURE);
+            }
+            
+            outputFileStream << outputStream.rdbuf();
+            outputFileStream.close();
+        }
+        else {
+            // Serialize to stdout
+            std::cout << outputStream.rdbuf();
+        }
+    }
+    
+    // Result
+    PrintResult(result);
+    return result.error.code;
+}

data/ext/snowcrash/src/win/RegexMatch.cc

@@ -0,0 +1,78 @@
+//
+//  RegexMatch.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/1/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <regex>
+#include <cstring>
+#include "RegexMatch.h"
+
+using namespace std;
+
+#if _MSC_VER == 1500
+using namespace std::tr1;
+#endif
+//
+// A C++09 implementation
+//
+
+bool snowcrash::RegexMatch(const string& target, const string& expression)
+{
+    if (target.empty() || expression.empty())
+        return false;
+    
+    try {
+        regex pattern(expression, regex_constants::extended);
+        return regex_search(target, pattern);
+    }
+    catch (const regex_error&) {
+    }
+    catch (...) {
+    }
+    
+    return false;
+}
+
+string snowcrash::RegexCaptureFirst(const string& target, const string& expression)
+{
+    CaptureGroups groups;
+    if (!RegexCapture(target, expression, groups) ||
+        groups.size() < 2)
+        return string();
+    
+    return groups[1];
+}
+
+bool snowcrash::RegexCapture(const string& target, const string& expression, CaptureGroups& captureGroups, size_t groupSize)
+{
+    if (target.empty() || expression.empty())
+        return false;
+    
+    captureGroups.clear();
+
+    try {
+        
+        regex pattern(expression, regex_constants::extended);
+        match_results<string::const_iterator> result;
+        if (!regex_search(target, result, pattern))
+            return false;
+    
+        for (match_results<string::const_iterator>::const_iterator it = result.begin();
+             it != result.end();
+             ++it) {
+
+            captureGroups.push_back(*it);
+        }
+
+        return true;
+    }
+    catch (const regex_error&) {
+    }
+    catch (...) {
+    }
+    
+    return false;
+}