ruco-cpp 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 938f24b2c00ffbe663d224f8a4bdc7e83ffd1399
+  data.tar.gz: f90f9b5745a5366f5094fe1ecffa697429204e1c
+SHA512:
+  metadata.gz: c9bf140c850998e1cfa9e4bde933861ce4cf30f84c3ed7ecfdb0a433d526d2ab359578e244eb86b1839b54fcaed3855c3487653b5db937e394aab2203faffdff
+  data.tar.gz: 80b235765f865e55b913c40ef547895d521d31382a6ff28dca478713ac866b5802bcea22f05bc7ae91f0af8bb33c34f0bf8bf898807a629e3454fa83ba659033

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+RSpec::Core::RakeTask.new(:spec)
+
+gemspec = Gem::Specification.load('ruco.gemspec')
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'cocor'
+  ext.ext_dir = 'ext/cocor'
+  ext.lib_dir = 'lib/cocor'
+  ext.gem_spec = gemspec
+  ext.source_pattern = "*.{c,cpp}" 
+end
+
+task :default => [:test]
+task :test => [:compile, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ruco"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/ruco

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require "ruco"
+require "cocor"
+require "fileutils"
+
+if ARGV.length < 1
+	puts "Usage: ruco <grammar.ruco> [Grammar Name]"
+	exit 1
+end
+
+file = ARGV[0]
+grammar_name = File.basename file, ".ruco"
+grammar_name = ARGV[1] if ARGV[1]
+
+rr = Ruco::Ruco.new grammar_name.capitalize do
+	instance_eval(File.read(file), file)
+end
+
+File.write("#{grammar_name}.atg",rr.generate_atg)
+File.write("#{grammar_name}.hpp",rr.generate_header)
+File.write("parse_#{grammar_name}.cpp",rr.generate_libcpp)
+File.write("parse_#{grammar_name}.hpp",rr.generate_libhpp)
+FileUtils.cp(File.join(Gem.datadir("ruco"), "picojson", "picojson.h"),"picojson.hpp")
+
+atg = File.join(Dir.pwd, "#{grammar_name}.atg")
+datadir = Gem.datadir "ruco"
+puts atg
+
+Cocor.compile atg, datadir, grammar_name.capitalize, "#{Dir.pwd}/"

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/data/ruco/Parser.frame

@@ -0,0 +1,359 @@
+/*-------------------------------------------------------------------------
+Compiler Generator Coco/R,
+Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
+extended by M. Loeberbauer & A. Woess, Univ. of Linz
+ported to C++ by Csaba Balazs, University of Szeged
+with improvements by Pat Terry, Rhodes University
+
+This program is free software; you can redistribute it and/or modify it 
+under the terms of the GNU General Public License as published by the 
+Free Software Foundation; either version 2, or (at your option) any 
+later version.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License 
+for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program; if not, write to the Free Software Foundation, Inc., 
+59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+As an exception, it is allowed to write an extension of Coco/R that is
+used as a plugin in non-free software.
+
+If not otherwise stated, any source code generated by Coco/R (other than 
+Coco/R itself) does not fall under the GNU General Public License.
+-------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------
+Parser.h Specification
+-----------------------------------------------------------------------*/
+
+-->begin
+
+#if !defined(-->prefixCOCO_PARSER_H__)
+#define -->prefixCOCO_PARSER_H__
+
+-->headerdef
+
+#include "Scanner.h"
+
+-->namespace_open
+
+class ParserException {
+
+	int line,col;
+	std::wstring message;
+
+public:
+	ParserException(int line, int col, std::wstring message) :
+	line(line), col(col), message(message)
+	{
+	}
+
+	int LineNumber() const
+	{
+		return line;
+	}
+
+	int ColumnNumber() const
+	{
+		return col;
+	}
+
+	std::wstring GetMessage() const
+	{
+		return message;
+	}
+};
+
+class Errors {
+public:
+	int count;			// number of errors detected
+	std::vector<ParserException> warnings;
+
+	Errors();
+	void SynErr(int line, int col, int n);
+	void Error(int line, int col, const wchar_t *s);
+	void Warning(int line, int col, const wchar_t *s);
+	void Warning(const wchar_t *s);
+	void Exception(const wchar_t *s);
+
+}; // Errors
+
+class Parser {
+private:
+-->constantsheader
+	Token *dummyToken;
+	int errDist;
+	int minErrDist;
+
+	void SynErr(int n);
+	void Get();
+	void Expect(int n);
+	bool StartOf(int s);
+	void ExpectWeak(int n, int follow);
+	bool WeakSeparator(int n, int syFol, int repFol);
+
+public:
+	Scanner *scanner;
+	Errors  *errors;
+
+	Token *t;			// last recognized token
+	Token *la;			// lookahead token
+
+-->declarations
+
+	Parser(Scanner *scanner);
+	~Parser();
+	void SemErr(const wchar_t* msg);
+
+-->productionsheader
+	void Parse();
+
+}; // end Parser
+
+-->namespace_close
+
+#endif
+
+-->implementation
+
+/*----------------------------------------------------------------------
+Parser.cpp Specification
+-----------------------------------------------------------------------*/
+
+-->begin
+
+#include <wchar.h>
+#include "Parser.h"
+#include "Scanner.h"
+
+
+-->namespace_open
+
+void Parser::SynErr(int n) {
+	if (errDist >= minErrDist) errors->SynErr(la->line, la->col, n);
+	errDist = 0;
+}
+
+void Parser::SemErr(const wchar_t* msg) {
+	if (errDist >= minErrDist) errors->Error(t->line, t->col, msg);
+	errDist = 0;
+}
+
+void Parser::Get() {
+	for (;;) {
+		t = la;
+		la = scanner->Scan();
+		if (la->kind <= maxT) { ++errDist; break; }
+-->pragmas
+		if (dummyToken != t) {
+			dummyToken->kind = t->kind;
+			dummyToken->pos = t->pos;
+			dummyToken->col = t->col;
+			dummyToken->line = t->line;
+			dummyToken->next = NULL;
+			coco_string_delete(dummyToken->val);
+			dummyToken->val = coco_string_create(t->val);
+			t = dummyToken;
+		}
+		la = t;
+	}
+}
+
+void Parser::Expect(int n) {
+	if (la->kind==n) Get(); else { SynErr(n); }
+}
+
+void Parser::ExpectWeak(int n, int follow) {
+	if (la->kind == n) Get();
+	else {
+		SynErr(n);
+		while (!StartOf(follow)) Get();
+	}
+}
+
+bool Parser::WeakSeparator(int n, int syFol, int repFol) {
+	if (la->kind == n) {Get(); return true;}
+	else if (StartOf(repFol)) {return false;}
+	else {
+		SynErr(n);
+		while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
+			Get();
+		}
+		return StartOf(syFol);
+	}
+}
+
+-->productions
+
+
+// If the user declared a method Init and a mehtod Destroy they should
+// be called in the contructur and the destructor respctively.
+//
+// The following templates are used to recognize if the user declared
+// the methods Init and Destroy.
+
+template<typename T>
+struct ParserInitExistsRecognizer {
+	template<typename U, void (U::*)() = &U::Init>
+	struct ExistsIfInitIsDefinedMarker{};
+
+	struct InitIsMissingType {
+		char dummy1;
+	};
+	
+	struct InitExistsType {
+		char dummy1; char dummy2;
+	};
+
+	// exists always
+	template<typename U>
+	static InitIsMissingType is_here(...);
+
+	// exist only if ExistsIfInitIsDefinedMarker is defined
+	template<typename U>
+	static InitExistsType is_here(ExistsIfInitIsDefinedMarker<U>*);
+
+	enum { InitExists = (sizeof(is_here<T>(NULL)) == sizeof(InitExistsType)) };
+};
+
+template<typename T>
+struct ParserDestroyExistsRecognizer {
+	template<typename U, void (U::*)() = &U::Destroy>
+	struct ExistsIfDestroyIsDefinedMarker{};
+
+	struct DestroyIsMissingType {
+		char dummy1;
+	};
+	
+	struct DestroyExistsType {
+		char dummy1; char dummy2;
+	};
+
+	// exists always
+	template<typename U>
+	static DestroyIsMissingType is_here(...);
+
+	// exist only if ExistsIfDestroyIsDefinedMarker is defined
+	template<typename U>
+	static DestroyExistsType is_here(ExistsIfDestroyIsDefinedMarker<U>*);
+
+	enum { DestroyExists = (sizeof(is_here<T>(NULL)) == sizeof(DestroyExistsType)) };
+};
+
+// The folloing templates are used to call the Init and Destroy methods if they exist.
+
+// Generic case of the ParserInitCaller, gets used if the Init method is missing
+template<typename T, bool = ParserInitExistsRecognizer<T>::InitExists>
+struct ParserInitCaller {
+	static void CallInit(T *t) {
+		// nothing to do
+	}
+};
+
+// True case of the ParserInitCaller, gets used if the Init method exists
+template<typename T>
+struct ParserInitCaller<T, true> {
+	static void CallInit(T *t) {
+		t->Init();
+	}
+};
+
+// Generic case of the ParserDestroyCaller, gets used if the Destroy method is missing
+template<typename T, bool = ParserDestroyExistsRecognizer<T>::DestroyExists>
+struct ParserDestroyCaller {
+	static void CallDestroy(T *t) {
+		// nothing to do
+	}
+};
+
+// True case of the ParserDestroyCaller, gets used if the Destroy method exists
+template<typename T>
+struct ParserDestroyCaller<T, true> {
+	static void CallDestroy(T *t) {
+		t->Destroy();
+	}
+};
+
+void Parser::Parse() {
+	t = NULL;
+	la = dummyToken = new Token();
+	la->val = coco_string_create(L"Dummy Token");
+	Get();
+-->parseRoot
+}
+
+Parser::Parser(Scanner *scanner) {
+-->constants
+	ParserInitCaller<Parser>::CallInit(this);
+	dummyToken = NULL;
+	t = la = NULL;
+	minErrDist = 2;
+	errDist = minErrDist;
+	this->scanner = scanner;
+	errors = new Errors();
+}
+
+bool Parser::StartOf(int s) {
+	const bool T = true;
+	const bool x = false;
+
+-->initialization
+
+	return set[s][la->kind];
+}
+
+Parser::~Parser() {
+	ParserDestroyCaller<Parser>::CallDestroy(this);
+	delete errors;
+	delete dummyToken;
+}
+
+Errors::Errors() {
+	count = 0;
+}
+
+void Errors::SynErr(int line, int col, int n) {
+	wchar_t* s;
+	switch (n) {
+-->errors
+		default:
+		{
+			wchar_t format[20];
+			coco_swprintf(format, 20, L"error %d", n);
+			s = coco_string_create(format);
+		}
+		break;
+	}
+	throw ParserException(line, col, s);
+	//wprintf(L"-- line %d col %d: %ls\n", line, col, s);
+	coco_string_delete(s);
+	count++;
+}
+
+void Errors::Error(int line, int col, const wchar_t *s) {
+	throw ParserException(line, col, s);
+	//wprintf(L"-- line %d col %d: %ls\n", line, col, s);
+	count++;
+}
+
+void Errors::Warning(int line, int col, const wchar_t *s) {
+	warnings.push_back(ParserException(line, col, s));
+	//wprintf(L"-- line %d col %d: %ls\n", line, col, s);
+}
+
+void Errors::Warning(const wchar_t *s) {
+	warnings.push_back(ParserException(0, 0, s));
+	//wprintf(L"%ls\n", s);
+}
+
+void Errors::Exception(const wchar_t* s) {
+	throw ParserException(0, 0, s);
+	//wprintf(L"%ls", s); 
+	exit(1);
+}
+
+-->namespace_close