redsnow 0.2.0 → 0.2.1

data/ext/snowcrash/src/SerializeYAML.h

@@ -10,12 +10,15 @@
 #define SNOWCRASH_SERIALIZE_YAML_H
 
 #include <ostream>
-#include "Blueprint.h"
+#include "BlueprintSourcemap.h"
 
 namespace snowcrash {
     
     // Naive YAML serialization to ostream
     void SerializeYAML(const snowcrash::Blueprint& blueprint, std::ostream &os);
+
+    // Naive Sourcmap YAML serialization to ostream
+    void SerializeSourceMapYAML(const snowcrash::SourceMap<snowcrash::Blueprint>& blueprint, std::ostream &os);
 }
 
 #endif

data/ext/snowcrash/src/SymbolTable.h

@@ -19,7 +19,7 @@
 #include "Serialize.h"
 #endif
 
-#include "Blueprint.h"
+#include "BlueprintSourcemap.h"
 #include "StringUtility.h"
 
 // Symbol identifier regex
@@ -36,15 +36,26 @@ namespace snowcrash {
     // Resource Object Symbol
     typedef std::pair<SymbolName, ResourceModel> ResourceModelSymbol;
 
+    // Resource Object Symbol source map
+    typedef std::pair<SymbolName, SourceMap<ResourceModel> > ResourceModelSymbolSourceMap;
+
     // Resource Object Symbol Table
     typedef std::map<SymbolName, ResourceModel> ResourceModelSymbolTable;
     
+    // Reesource Object Symbol Table source map
+    typedef std::map<SymbolName, SourceMap<ResourceModel> > ResourceModelSymbolSourceMapTable;
+
     struct SymbolTable {
         
         // Resource Object Symbol Table
         ResourceModelSymbolTable resourceModels;
     };
     
+    struct SymbolSourceMapTable {
+
+        // Resource Object Symbol Table source map
+        ResourceModelSymbolSourceMapTable resourceModels;
+    };
     
     // Checks whether given source data represents reference to a symbol returning true if so,
     // false otherwise. If source data is represent reference referred symbol name is filled in.

data/ext/snowcrash/src/ValuesParser.h

@@ -18,9 +18,6 @@
 
 namespace snowcrash {
 
-    /** Parameter Values */
-    typedef Collection<Value>::type Values; // TODO: Move this into core later
-
     /** Parameter Values matching regex */
     const char* const ValuesRegex = "^[[:blank:]]*[Vv]alues[[:blank:]]*$";
 
@@ -33,8 +30,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         Report& report,
-                                                         Values& out) {
+                                                         ParseResult<Values>& out) {
 
             if (pd.sectionContext() == ValueSectionType) {
 
@@ -44,7 +40,13 @@ namespace snowcrash {
                 RegexCapture(content, PARAMETER_VALUE, captureGroups);
 
                 if (captureGroups.size() > 1) {
-                    out.push_back(captureGroups[1]);
+                    out.node.push_back(captureGroups[1]);
+
+                    if (pd.exportSourceMap()) {
+                        SourceMap<Value> valueSM;
+                        valueSM.sourceMap = node->sourceMap;
+                        out.sourceMap.collection.push_back(valueSM);
+                    }
                 } else {
                     TrimString(content);
 
@@ -54,9 +56,9 @@ namespace snowcrash {
                     ss << ", expected '`" << content << "`'";
 
                     mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    report.warnings.push_back(Warning(ss.str(),
-                                                      IgnoringWarning,
-                                                      sourceMap));
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          IgnoringWarning,
+                                                          sourceMap));
                 }
 
                 return ++MarkdownNodeIterator(node);
@@ -68,8 +70,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       Report& report,
-                                                       Values& out) {
+                                                       ParseResult<Values>& out) {
 
             return node;
         }

data/ext/snowcrash/src/Version.h

@@ -15,7 +15,7 @@
 #define SNOWCRASH_VERSION_H
 
 #define SNOWCRASH_MAJOR_VERSION 0
-#define SNOWCRASH_MINOR_VERSION 14
+#define SNOWCRASH_MINOR_VERSION 15
 #define SNOWCRASH_PATCH_VERSION 0
 
 #define SNOWCRASH_VERSION_IS_RELEASE 1

data/ext/snowcrash/src/csnowcrash.cc

@@ -9,15 +9,19 @@
 #include "csnowcrash.h"
 #include "snowcrash.h"
 
-int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint)
+int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint, sc_sm_blueprint_t** sm_blueprint)
 {
     snowcrash::Report* t_report = ::new snowcrash::Report;
     snowcrash::Blueprint* t_blueprint = ::new snowcrash::Blueprint;
+    snowcrash::SourceMap<snowcrash::Blueprint>* t_sm_blueprint = ::new snowcrash::SourceMap<snowcrash::Blueprint>;
 
-    int ret = snowcrash::parse(source, option, *t_report, *t_blueprint);
+    snowcrash::ParseResult<snowcrash::Blueprint>* t_parse_result = ::new snowcrash::ParseResult<snowcrash::Blueprint>(*t_report, *t_blueprint, *t_sm_blueprint);
+
+    int ret = snowcrash::parse(source, option, *t_parse_result);
 
-    *blueprint = AS_TYPE(sc_blueprint_t, t_blueprint);
     *report = AS_TYPE(sc_report_t, t_report);
+    *blueprint = AS_TYPE(sc_blueprint_t, t_blueprint);
+    *sm_blueprint = AS_TYPE(sc_sm_blueprint_t, t_sm_blueprint);
 
     return ret;
 }

data/ext/snowcrash/src/csnowcrash.h

@@ -12,6 +12,7 @@
 
 #include "CSourceAnnotation.h"
 #include "CBlueprint.h"
+#include "CBlueprintSourcemap.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,9 +28,10 @@ extern "C" {
      *
      *  \return Error status code. Zero represents success, non-zero a failure.
      *
-     *  \this function will allocate `report` and `blueprint`, for deallocation `sc_blueprint_free` and `sc_report_free` should be called.
+     *  this function will allocate `report` and `blueprint`, `sm_blueprint`,
+     *  for deallocation `sc_blueprint_free`, `sc_sm_blueprint_free` and `sc_report_free` should be called.
      */
-    SC_API int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint);
+    SC_API int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint, sc_sm_blueprint_t** sm_blueprint);
 
 #ifdef __cplusplus
 }

data/ext/snowcrash/src/snowcrash.cc

@@ -7,7 +7,6 @@
 //
 
 #include "snowcrash.h"
-#include "MarkdownParser.h"
 #include "BlueprintParser.h"
 
 const int snowcrash::SourceAnnotation::OK = 0;
@@ -20,6 +19,7 @@ using namespace snowcrash;
  */
 static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
 {
+
     std::string::size_type pos = source.find("\t");
 
     if (pos != std::string::npos) {
@@ -49,18 +49,17 @@ static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
 
 int snowcrash::parse(const mdp::ByteBuffer& source,
                      BlueprintParserOptions options,
-                     Report& report,
-                     Blueprint& blueprint)
+                     ParseResult<Blueprint>& out)
 {
     try {
         
         // Sanity Check
-        if (!CheckSource(source, report))
-            return report.error.code;
+        if (!CheckSource(source, out.report))
+            return out.report.error.code;
         
         // Do nothing if blueprint is empty
         if (source.empty())
-            return report.error.code;
+            return out.report.error.code;
 
         // Parse Markdown
         mdp::MarkdownParser markdownParser;
@@ -68,21 +67,21 @@ int snowcrash::parse(const mdp::ByteBuffer& source,
         markdownParser.parse(source, markdownAST);
 
         // Build SectionParserData
-        SectionParserData pd(options, source, blueprint);
+        SectionParserData pd(options, source, out.node);
 
         // Parse Blueprint
-        BlueprintParser::parse(markdownAST.children().begin(), markdownAST.children(), pd, report, blueprint);
+        BlueprintParser::parse(markdownAST.children().begin(), markdownAST.children(), pd, out);
     }
     catch (const std::exception& e) {
         
         std::stringstream ss;
         ss << "parser exception: '" << e.what() << "'";
-        report.error = Error(ss.str(), 1);
+        out.report.error = Error(ss.str(), 1);
     }
     catch (...) {
         
-        report.error = Error("parser exception has occured", 1);
+        out.report.error = Error("parser exception has occured", 1);
     }
 
-    return report.error.code;
+    return out.report.error.code;
 }

data/ext/snowcrash/src/snowcrash.h

@@ -9,7 +9,7 @@
 #ifndef SNOWCRASH_H
 #define SNOWCRASH_H
 
-#include "Blueprint.h"
+#include "BlueprintSourcemap.h"
 #include "SourceAnnotation.h"
 #include "SectionParser.h"
 
@@ -35,12 +35,12 @@ namespace snowcrash {
      *  \param options       Parser options. Use 0 for no additional options.
      *  \param report        Parsing report.
      *  \param blueprint     Parsed blueprint AST.
+     *  \param blueprintSM   Blueprint sourcemap AST
      *  \return Error status code. Zero represents success, non-zero a failure.
      */
     int parse(const mdp::ByteBuffer& source,
               BlueprintParserOptions options,
-              Report& report,
-              Blueprint& blueprint);
+              ParseResult<Blueprint>& out);
 }
 
 #endif

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

@@ -21,6 +21,7 @@ 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 SourcemapArgument = "sourcemap";
 static const std::string ValidateArgument = "validate";
 static const std::string VersionArgument = "version";
 
@@ -81,13 +82,16 @@ int main(int argc, const char *argv[])
 
     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"));
+    argumentParser.add<std::string>(SourcemapArgument, 's', "export sourcemap AST into file", false);
     // TODO: argumentParser.add("render", 'r', "render markdown descriptions");
     argumentParser.add("help", 'h', "display this help message");
     argumentParser.add(VersionArgument, 'v', "print Snow Crash version");
@@ -118,6 +122,7 @@ int main(int argc, const char *argv[])
         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);
@@ -127,29 +132,40 @@ int main(int argc, const char *argv[])
         inputFileStream.close();
     }
 
-    // Parse
+    // Initialize
     snowcrash::BlueprintParserOptions options = 0;  // Or snowcrash::RequireBlueprintNameOption
-    snowcrash::Report report;
-    snowcrash::Blueprint blueprint;
-    snowcrash::parse(inputStream.str(), options, report, blueprint);
+    snowcrash::ParseResult<snowcrash::Blueprint> blueprint;
+
+    if (argumentParser.exist(SourcemapArgument)) {
+        options |= snowcrash::ExportSourcemapOption;
+    }
+
+    // Parse
+    snowcrash::parse(inputStream.str(), options, blueprint);
 
     // Output
     if (!argumentParser.exist(ValidateArgument)) {
         
         std::stringstream outputStream;
+        std::stringstream sourcemapOutputStream;
 
         if (argumentParser.get<std::string>(FormatArgument) == "json") {
-            SerializeJSON(blueprint, outputStream);
+            SerializeJSON(blueprint.node, outputStream);
+            SerializeSourceMapJSON(blueprint.sourceMap, sourcemapOutputStream);
         }
         else if (argumentParser.get<std::string>(FormatArgument) == "yaml") {
-            SerializeYAML(blueprint, outputStream);
+            SerializeYAML(blueprint.node, outputStream);
+            SerializeSourceMapYAML(blueprint.sourceMap, sourcemapOutputStream);
         }
         
         std::string outputFileName = argumentParser.get<std::string>(OutputArgument);
+        std::string sourcemapOutputFileName = argumentParser.get<std::string>(SourcemapArgument);
+
         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);
@@ -162,9 +178,23 @@ int main(int argc, const char *argv[])
             // Serialize to stdout
             std::cout << outputStream.rdbuf();
         }
+        
+        if (!sourcemapOutputFileName.empty()) {
+            // Serialize to file
+            std::ofstream sourcemapOutputFileStream;
+            sourcemapOutputFileStream.open(sourcemapOutputFileName.c_str());
+            
+            if (!sourcemapOutputFileStream.is_open()) {
+                std::cerr << "fatal: unable to write to file '" << sourcemapOutputFileName << "'\n";
+                exit(EXIT_FAILURE);
+            }
+            
+            sourcemapOutputFileStream << sourcemapOutputStream.rdbuf();
+            sourcemapOutputFileStream.close();
+        }
     }
 
     // report
-    PrintReport(report);
-    return report.error.code;
+    PrintReport(blueprint.report);
+    return blueprint.report.error.code;
 }

data/ext/snowcrash/tools/homebrew/snowcrash.rb

@@ -2,7 +2,7 @@ require 'formula'
 
 class Snowcrash < Formula
   homepage 'http://apiblueprint.org'
-  head 'https://github.com/apiaryio/snowcrash.git', :tag => 'v0.14.0'
+  head 'https://github.com/apiaryio/snowcrash.git', :tag => 'v0.15.0'
 
   def install
     system "./configure"

data/lib/redsnow.rb

@@ -1,11 +1,41 @@
 require "redsnow/version"
 require "redsnow/binding"
 require "redsnow/blueprint"
+require "redsnow/sourcemap"
 require "redsnow/parseresult"
 require "ffi"
 
 module RedSnow
   include Binding
+
+  # Options
+  EXPORT_SOURCEMAP_OPTION_KEY = :'exportSourcemap'
+  REQUIRE_BLUEPRINT_NAME_OPTION_KEY = :'requireBlueprintName'
+
+  # Parse options
+  attr_accessor :options
+  def self.parse_options(options)
+    # Parse Options
+    unless options.is_a?(Numeric)
+      opt = 0
+      if options.has_key?(REQUIRE_BLUEPRINT_NAME_OPTION_KEY)
+        if options[REQUIRE_BLUEPRINT_NAME_OPTION_KEY] === true
+          opt = opt | (1 << 1)
+        end
+      end
+
+      if options.has_key?(EXPORT_SOURCEMAP_OPTION_KEY)
+        if options[EXPORT_SOURCEMAP_OPTION_KEY] === true
+          opt = opt | (1 << 2)
+        end
+      end
+
+      return opt
+    else
+      return options
+    end
+  end
+
   # parse
   #   parsing API Blueprint into Ruby objects
   # @param rawBlueprint [String] API Blueprint
@@ -13,17 +43,26 @@ module RedSnow
   #
   # @return [ParseResult]
   def self.parse(rawBlueprint, options = 0)
+
+    raise ArgumentError.new("Expected string value") unless rawBlueprint.is_a?(String)
+
+    blueprintOptions = self.parse_options(options)
+
     blueprint = FFI::MemoryPointer.new :pointer
+    sourcemap = FFI::MemoryPointer.new :pointer
     report = FFI::MemoryPointer.new :pointer
-    ret = RedSnow::Binding.sc_c_parse(rawBlueprint, options, report, blueprint)
+
+    RedSnow::Binding.sc_c_parse(rawBlueprint, blueprintOptions, report, blueprint, sourcemap)
 
     blueprint = blueprint.get_pointer(0)
+    sourcemap = sourcemap.get_pointer(0)
     report = report.get_pointer(0)
 
-    parseResult = ParseResult.new(blueprint, report)
+    parseResult = ParseResult.new(report, blueprint, sourcemap)
 
     return parseResult
   ensure
+    RedSnow::Binding.sc_sm_blueprint_free(sourcemap)
     RedSnow::Binding.sc_blueprint_free(blueprint)
     RedSnow::Binding.sc_report_free(report)
   end

data/lib/redsnow/binding.rb

@@ -16,10 +16,11 @@ module RedSnow
     # @see https://github.com/apiaryio/snowcrash/blob/master/src/BlueprintParserCore.h#L31
     enum :option, [
         :render_descriptions_option,
-        :require_blueprint_name_option
+        :require_blueprint_name_option,
+        :export_sourcemap_option
     ]
 
-    attach_function("sc_c_parse", "sc_c_parse", [ :string, :option, :pointer, :pointer ], :int)
+    attach_function("sc_c_parse", "sc_c_parse", [ :string, :option, :pointer, :pointer, :pointer ], :int)
 
     attach_function("sc_blueprint_free", "sc_blueprint_free", [ :pointer ], :void)
     attach_function("sc_blueprint_name", "sc_blueprint_name", [ :pointer ], :string)
@@ -32,12 +33,12 @@ module RedSnow
     attach_function("sc_metadata_key", "sc_metadata_key", [ :pointer ], :string)
     attach_function("sc_metadata_value", "sc_metadata_value",[ :pointer ], :string)
 
-    attach_function("sc_resource_groups_collection_handle", "sc_resource_groups_collection_handle", [ :pointer ], :pointer)
-    attach_function("sc_resource_groups_collection_size", "sc_resource_groups_collection_size", [ :pointer ], :int)
+    attach_function("sc_resource_group_collection_handle", "sc_resource_group_collection_handle", [ :pointer ], :pointer)
+    attach_function("sc_resource_group_collection_size", "sc_resource_group_collection_size", [ :pointer ], :int)
 
-    attach_function("sc_resource_groups_handle", "sc_resource_groups_handle", [ :pointer, :int ], :pointer)
-    attach_function("sc_resource_groups_name", "sc_resource_groups_name", [ :pointer ], :string)
-    attach_function("sc_resource_groups_description", "sc_resource_groups_description", [ :pointer ], :string)
+    attach_function("sc_resource_group_handle", "sc_resource_group_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_resource_group_name", "sc_resource_group_name", [ :pointer ], :string)
+    attach_function("sc_resource_group_description", "sc_resource_group_description", [ :pointer ], :string)
 
     attach_function("sc_resource_collection_handle", "sc_resource_collection_handle", [ :pointer ] , :pointer)
     attach_function("sc_resource_collection_size", "sc_resource_collection_size", [ :pointer ], :int)
@@ -54,6 +55,7 @@ module RedSnow
     attach_function("sc_payload_handle", "sc_payload_handle", [ :pointer, :int ], :pointer)
     attach_function("sc_payload_handle_resource", "sc_payload_handle_resource", [ :pointer ], :pointer)
     attach_function("sc_payload_name", "sc_payload_name", [ :pointer ], :string)
+    attach_function("sc_payload_symbol", "sc_payload_symbol", [ :pointer ], :string)
     attach_function("sc_payload_description", "sc_payload_description", [ :pointer ], :string)
     attach_function("sc_payload_body", "sc_payload_body", [ :pointer ], :string)
     attach_function("sc_payload_schema", "sc_payload_schema", [ :pointer ], :string)
@@ -81,7 +83,7 @@ module RedSnow
     attach_function("sc_value_collection_size", "sc_value_collection_size", [ :pointer ], :int)
 
     attach_function("sc_value_handle", "sc_value_handle", [ :pointer, :int ], :pointer)
-    attach_function("sc_value_string", "sc_value_string", [ :pointer], :string)
+    attach_function("sc_value", "sc_value", [ :pointer], :string)
 
     attach_function("sc_header_collection_handle_payload", "sc_header_collection_handle_payload", [ :pointer ], :pointer)
     attach_function("sc_header_collection_handle_resource", "sc_header_collection_handle_resource", [ :pointer ], :pointer)
@@ -126,6 +128,89 @@ module RedSnow
     attach_function("sc_warning_code", "sc_warning_code", [ :pointer], :int)
     attach_function("sc_warning_ok", "sc_warning_ok", [ :pointer ], :int)
 
+    # Sourcemap's c-interface functions
+    attach_function("sc_source_map_size", "sc_source_map_size", [ :pointer ], :int)
+    attach_function("sc_source_map_length", "sc_source_map_length", [ :pointer, :int ], :int)
+    attach_function("sc_source_map_location", "sc_source_map_location", [ :pointer, :int ], :int)
+
+    attach_function("sc_sm_blueprint_free", "sc_sm_blueprint_free", [ :pointer ], :void)
+    attach_function("sc_sm_blueprint_name", "sc_sm_blueprint_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_blueprint_description", "sc_sm_blueprint_description", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_metadata_collection_handle", "sc_sm_metadata_collection_handle", [ :pointer ], :pointer)
+    attach_function("sc_sm_metadata_collection_size", "sc_sm_metadata_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_metadata_handle", "sc_sm_metadata_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_metadata", "sc_sm_metadata", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_resource_group_collection_handle", "sc_sm_resource_group_collection_handle", [ :pointer ], :pointer)
+    attach_function("sc_sm_resource_group_collection_size", "sc_sm_resource_group_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_resource_group_handle", "sc_sm_resource_group_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_resource_group_name", "sc_sm_resource_group_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_resource_group_description", "sc_sm_resource_group_description", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_resource_collection_handle", "sc_sm_resource_collection_handle", [ :pointer ] , :pointer)
+    attach_function("sc_sm_resource_collection_size", "sc_sm_resource_collection_size", [ :pointer ], :int)
+    # Resource
+    attach_function("sc_sm_resource_handle", "sc_sm_resource_handle", [ :pointer, :int ] , :pointer)
+    attach_function("sc_sm_resource_uritemplate", "sc_sm_resource_uritemplate", [ :pointer ], :pointer)
+    attach_function("sc_sm_resource_name", "sc_sm_resource_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_resource_description", "sc_sm_resource_description", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_payload_collection_handle_requests", "sc_sm_payload_collection_handle_requests", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_collection_handle_responses", "sc_sm_payload_collection_handle_responses", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_collection_size", "sc_sm_payload_collection_size", [ :pointer ], :int)
+    # Resource.model
+    attach_function("sc_sm_payload_handle", "sc_sm_payload_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_payload_handle_resource", "sc_sm_payload_handle_resource", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_name", "sc_sm_payload_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_symbol", "sc_sm_payload_symbol", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_description", "sc_sm_payload_description", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_body", "sc_sm_payload_body", [ :pointer ], :pointer)
+    attach_function("sc_sm_payload_schema", "sc_sm_payload_schema", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_parameter_collection_handle_payload", "sc_sm_parameter_collection_handle_payload", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_collection_handle_resource", "sc_sm_parameter_collection_handle_resource", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_collection_handle_action", "sc_sm_parameter_collection_handle_action", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_collection_size", "sc_sm_parameter_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_parameter_handle", "sc_sm_parameter_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_parameter_name", "sc_sm_parameter_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_description", "sc_sm_parameter_description", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_type", "sc_sm_parameter_type", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_parameter_use", "sc_sm_parameter_parameter_use", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_default_value", "sc_sm_parameter_default_value", [ :pointer ], :pointer)
+    attach_function("sc_sm_parameter_example_value", "sc_sm_parameter_example_value", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_value_collection_handle", "sc_sm_value_collection_handle", [ :pointer], :pointer)
+    attach_function("sc_sm_value_collection_size", "sc_sm_value_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_value_handle", "sc_sm_value_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_value", "sc_sm_value", [ :pointer], :pointer)
+
+    attach_function("sc_sm_header_collection_handle_payload", "sc_sm_header_collection_handle_payload", [ :pointer ], :pointer)
+    attach_function("sc_sm_header_collection_handle_resource", "sc_sm_header_collection_handle_resource", [ :pointer ], :pointer)
+    attach_function("sc_sm_header_collection_handle_action", "sc_sm_header_collection_handle_action", [ :pointer ], :pointer)
+    attach_function("sc_sm_header_collection_size", "sc_sm_header_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_header_handle", "sc_sm_header_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_header", "sc_sm_header", [ :pointer], :pointer)
+
+    attach_function("sc_sm_action_collection_handle", "sc_sm_action_collection_handle", [ :pointer ], :pointer)
+    attach_function("sc_sm_action_collection_size", "sc_sm_action_collection_size", [ :pointer], :int)
+
+    attach_function("sc_sm_action_handle", "sc_sm_action_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_action_httpmethod", "sc_sm_action_httpmethod", [ :pointer], :pointer)
+    attach_function("sc_sm_action_name", "sc_sm_action_name", [ :pointer], :pointer)
+    attach_function("sc_sm_action_description", "sc_sm_action_description", [ :pointer ], :pointer)
+
+    attach_function("sc_sm_transaction_example_collection_handle", "sc_sm_transaction_example_collection_handle", [ :pointer ], :pointer)
+    attach_function("sc_sm_transaction_example_collection_size", "sc_sm_transaction_example_collection_size", [ :pointer ], :int)
+
+    attach_function("sc_sm_transaction_example_handle", "sc_sm_transaction_example_handle", [ :pointer, :int ], :pointer)
+    attach_function("sc_sm_transaction_example_name", "sc_sm_transaction_example_name", [ :pointer ], :pointer)
+    attach_function("sc_sm_transaction_example_description", "sc_sm_transaction_example_description", [ :pointer ], :pointer)
 
   end