Skip to content

N
node-sass
Commit 19f9e84a by Hampton Catlin
Options

goodbye, sweet origial c interface...

parent a5792b84
Showing with 0 additions and 1003 deletions
c/Makefile deleted 100644 → 0
CC=gcc
CFLAGS=-I. -Wall -g
BIN=bin/
sassc: sassc.o
$(CC) $(CFLAGS) -o $(BIN)sassc sassc.o libsass.o context.o parser.o emitter.o transforms.o
sassc.o: libsass.o
libsass.o: context.o parser.o emitter.o transforms.o
bstr: bstr/bsafe.o
bstr/bsafe.o:
build: prefix.o context.o exception.o parser.o
prefix.o:
exception.o:
context.o: tree.h
parser.o: context.o
emitter.o: context.o
transforms.o: context.o
test: clean build sassc
./spec.rb spec/basic/
test_context: context.o test_context.o
$(CC) $(CFLAGS) -o $(BIN)test_context test_context.o context.o
./$(BIN)test_context
test_context.o:
clean: clean_bin
rm -rf *.o
clean_bin:
rm -rf bin/*
\ No newline at end of file
c/array.h deleted 100644 → 0
#define DECLARE_SASS_ARRAY_OF(type) \
typedef struct { \
size_t length; \
size_t capacity; \
type *contents; \
} sass_ ## type ## _array; \
sass_ ## type ## _array sass_make_ ## type ## _array(size_t cap); \
void sass_ ## type ## _array_push(sass_ ## type ## _array *a, type elem); \
void sass_ ## type ## _array_cat(sass_ ## type ## _array *a, sass_ ## type ## _array *b); \
void sass_free_ ## type ## _array(sass_ ## type ## _array *a)
#define DEFINE_SASS_ARRAY_OF(type) \
sass_ ## type ## _array sass_make_ ## type ## _array(size_t cap) { \
sass_ ## type ## _array a; \
a.contents = (type *) malloc(cap * sizeof(type)); \
if (!a.contents) { \
printf("ERROR: unable to allocate array of %s\n", #type); \
abort(); \
} \
a.capacity = cap; \
a.length = 0; \
return a; \
} \
void sass_ ## type ## _array_push(sass_ ## type ## _array *a, type elem) { \
size_t len = a->length, cap = a->capacity; \
if (len < cap) { \
a->contents[len] = elem; \
a->length++; \
} \
else { \
type *new = (type *) realloc(a->contents, len * 2); \
if (!new) { \
printf("ERROR: unable to resize array of %s\n", #type); \
abort(); \
} \
else { \
new[len] = elem; \
a->contents = new; \
a->length++; \
a->capacity = len * 2; \
} \
} \
} \
void sass_ ## type ## _array_cat(sass_ ## type ## _array *a, sass_ ## type ## _array *b) { \
size_t b_len = b->length; \
type *b_cont = b->contents; \
int i; \
for (i = 0; i < b_len; i++) sass_ ## type ## _array_push(a, b_cont[i]); \
}
c/chars.txt deleted 100644 → 0
#header > #leftpane > [data-ur-tabs-component="button"] {
> div {
padding: 10px;
}
> div:after {
content: "▼";
float: right;
}
&[data-ur-state="enabled"] > div:after {
content: "▲";
float: right;
}
}
\ No newline at end of file
c/context.c deleted 100644 → 0
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "context.h"
static sass_context *sass_alloc_context() {
sass_context *ctx = malloc(sizeof(sass_context));
if (!ctx) {
printf("ERROR: could not allocate Sass context object.\n");
abort();
}
return ctx;
}
static char *sass_read_file(char *path) {
FILE *f;
f = fopen(path, "rb");
if (!f) {
printf("ERROR: could not open Sass source file %s", path);
abort();
}
fseek(f, 0L, SEEK_END);
int len = ftell(f);
rewind(f);
char *buf = (char *)malloc(len * sizeof(char) + 1);
fread(buf, sizeof(char), len, f);
buf[len] = '\0';
fclose(f);
return buf;
}
sass_context *sass_make_context_from_file(char *path) {
sass_context *ctx = sass_alloc_context();
ctx->path = path;
ctx->pos = ctx->src = sass_read_file(path);
ctx->line = 1;
return ctx;
}
sass_context *sass_make_context_from_string(char *src) {
size_t len = strlen(src);
sass_context *ctx = sass_alloc_context();
if (!(ctx->pos = ctx->src = (char *) malloc(len * sizeof(char) + 1) )) {
printf("ERROR: could not copy Sass source string.\n");
abort();
}
memcpy(ctx->src, src, len);
ctx->src[len] = '\0';
ctx->line = 1;
return ctx;
}
void sass_free_context(sass_context *ctx) {
free(ctx->src);
free(ctx);
}
c/context.h deleted 100644 → 0
#include <setjmp.h>
#include <stdlib.h>
#include "tree.h"
#define CONTEXT_HEADER
/*
Probably gonna' need to stratify this a bit more. A context object will store
the symbol table and any other necessary project-wide info. Each sass_document
struct will store src strings, line counts, etc.
*/
typedef struct {
char *path; /* the full directory+filename of the source file */
char *src; /* the text of the entire source file */
char *result; /* the final result, after all compiling */
char *pos; /* keeps track of the parser's current position */
size_t line; /* the number of the line currently being parsed */
jmp_buf env; /* the top of the exception-handling stack */
sass_document *doc; /* the primary AST tree */
sass_document **imports; /* all imported files */
/* more to come */
} sass_context;
sass_context *sass_make_context_from_file(char *path);
sass_context *sass_make_context_from_string(char *src);
c/emitter.c deleted 100644 → 0
#include "emitter.h"
int sass_emit(sass_context *ctx) {
ctx->result = ctx->doc->src;
return 0;
}
\ No newline at end of file
c/emitter.h deleted 100644 → 0
#ifndef CONTEXT_HEADER
#include "context.h"
#endif
int sass_emit(sass_context *ctx);
\ No newline at end of file
c/exception.c deleted 100644 → 0
#include <stdlib.h>
#include <stdio.h>
#include "exception.h"
raise(int code) {
printf("Aborted with error code %d.", code);
abort();
}
\ No newline at end of file
c/exception.h deleted 100644 → 0
raise(int);
\ No newline at end of file
c/file.c deleted 100644 → 0
#include <stdlib.h>
#include <stdio.h>
#include "file.h"
char *sass_read_file(char *path) {
FILE *f;
f = fopen(path, "rb");
if (!f) {
printf("ERROR: could not open file %s", path);
abort();
}
fseek(f, 0L, SEEK_END);
int len = ftell(f);
rewind(f);
char *buf = (char *)malloc(len * sizeof(char) + 1);
fread(buf, sizeof(char), len, f);
buf[len] = '\0';
fclose(f);
return buf;
}
\ No newline at end of file
c/file.h deleted 100644 → 0
char *sass_read_file(char *);
\ No newline at end of file
c/grammar.md deleted 100644 → 0
Initial pass at a Sass grammar. Nowhere close to complete.
stylesheet -> statement*
statement -> ruleset
ruleset -> SELECTOR '{' declarations '}'
declarations -> rule [';' declarations]?
-> ruleset declarations?
-> []
rule -> property ':' value
-> []
\ No newline at end of file
c/libsass.c deleted 100644 → 0
#include "libsass.h"
#include "emitter.h"
#include "transforms.h"
#include "parser.h"
char * sass_file_compile(char *filepath, int options) {
sass_context *ctx = sass_make_context_from_file(filepath);
return ctx->src;
}
char * sass_string_compile(char *input, int options) {
sass_context *ctx = sass_make_context_from_string(input);
return ctx->src;
}
char * sass_compile(sass_context *ctx) {
sass_parse(ctx);
sass_transform(ctx);
sass_emit(ctx);
return ctx->result;
}
\ No newline at end of file
c/libsass.h deleted 100644 → 0
#include "bstr/bstrlib.h"
char * sass_file_compile(char *filepath, int options);
char * sass_string_compile(char *input, int options);
c/parser.c deleted 100644 → 0
#include <stdlib.h>
#include "parser.h"
#include "prefix.h"
DEFINE_SASS_ARRAY_OF(sass_node_ptr);
sass_token sass_make_token(int lexeme, char *beg, char *end) {
sass_token t;
t.lexeme = lexeme;
t.beg = beg;
t.end = end;
return t;
}
int sass_parse(sass_context *ctx) {
sass_document *doc = (sass_document*)malloc(sizeof(sass_document));
doc->src = ctx->src;
return 0;
}
sass_sass_node_ptr_array sass_parse(sass_context *ctx) {
/* not sure how big of an array to allocate by default */
sass_sass_node_ptr_array statements = sass_make_sass_node_ptr_array(16);
while (ctx->*p) sass_sass_node_ptr_array_push(statements, sass_parse_statement(ctx));
return statements;
}
static sass_node_ptr sass_parse_statement(sass_context *ctx) {
/* currently only handles rulesets; will expand to handle atkeywords */
return sass_parse_ruleset(ctx);
}
static sass_node_ptr sass_parse_ruleset(sass_context *ctx) {
sass_node_ptr selector = sass_parse_selector(ctx);
sass_node_ptr declarations = sass_parse_declarations(ctx);
return sass_make_node(RULESET, selector, declarations);
}
static sass_node_ptr sass_parse_selector(sass_context *ctx) {
/* will eventually need to be much more complicated */
char *lbrace = sass_prefix_find_first(ctx->pos, sass_prefix_is_lbrace);
sass_node_ptr node = sass_make_node(SELECTOR);
node->token = sass_make_token(SELECTOR, pos, lbrace);
ctx->pos = lbrace;
return node;
}
\ No newline at end of file
c/parser.h deleted 100644 → 0
#ifndef CONTEXT_HEADER
#include "context.h"
#endif
#include "array.h"
enum {
IDENT,
ATKEYWORD,
STRING,
IDNAME,
CLASSNAME,
NUMBER,
PERCENTAGE,
DIMENSION,
URI,
SPACES,
COMMENT,
FUNCTION,
EXACTMATCH,
INCLUDES,
DASHMATCH,
PREFIXMATCH,
SUFFIXMATCH,
SUBSTRINGMATCH
};
typedef struct {
int lexeme;
char *beg;
char *end;
} Token;
#define sass_peek_token(src, lexeme) (sass_prefix_is_ ## lexeme(src))
int sass_parse(sass_context *ctx);
\ No newline at end of file
c/prefix.c deleted 100644 → 0
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include "prefix.h"
char *sass_prefix_is_char(char *src, char pre) {
return pre == *src ? src+1 : NULL;
}
char *sass_prefix_is_chars(char *src, char *pre) {
while (*pre && *src == *pre) src++, pre++;
return *pre ? NULL : src;
}
char *sass_prefix_is_one_of(char *src, char *class) {
while(*class && *src != *class) class++;
return *class ? src+1 : NULL;
}
char *sass_prefix_is_some_of(char *src, char *class) {
char *p = src;
while(sass_prefix_is_one_of(p, class)) p++;
return p == src ? NULL : p;
}
char *sass_prefix_is_delimited_by(char *src, char *beg, char *end, int esc) {
src = sass_prefix_is_chars(src, beg);
if (!src) return NULL;
char *stop;
while (1) {
if (!*src) return NULL;
stop = sass_prefix_is_chars(src, end);
if (stop && (!esc || *(src-1) != '\\')) return stop;
src = stop ? stop : src+1;
}
}
char *sass_prefix_epsilon(char *src) {
return src;
}
char *sass_prefix_not(char *src, sass_prefix_matcher m) {
return m(src) ? NULL : src;
}
char *_sass_prefix_alternatives(char *src, ...) {
va_list ap;
va_start(ap, src);
sass_prefix_matcher m = va_arg(ap, sass_prefix_matcher);
char *p = NULL;
while (m && !(p = (*m)(src))) m = va_arg(ap, sass_prefix_matcher);
va_end(ap);
return p;
}
char *_sass_prefix_sequence(char *src, ...) {
va_list ap;
va_start(ap, src);
sass_prefix_matcher m;
while ((m = va_arg(ap, sass_prefix_matcher)) && (src = (*m)(src))) ;
return src;
}
char *sass_prefix_optional(char *src, sass_prefix_matcher m) {
char *p = m(src);
return p ? p : src;
}
char *sass_prefix_zero_plus(char *src, sass_prefix_matcher m) {
char *p = m(src);
while(p) src = p, p = m(src);
return src;
}
char *sass_prefix_one_plus(char *src, sass_prefix_matcher m) {
char *p = m(src);
if (!p) return NULL;
while(p) src = p, p = m(src);
return src;
}
char *sass_prefix_find_first(char *src, sass_prefix_matcher m) {
while (*src && !m(src)) src++;
return *src ? src : NULL;
}
SINGLE_CTYPE_MATCHER(space);
SINGLE_CTYPE_MATCHER(alpha);
SINGLE_CTYPE_MATCHER(digit);
SINGLE_CTYPE_MATCHER(xdigit);
SINGLE_CTYPE_MATCHER(alnum);
SINGLE_CTYPE_MATCHER(punct);
CTYPE_SEQUENCE_MATCHER(space);
CTYPE_SEQUENCE_MATCHER(alpha);
CTYPE_SEQUENCE_MATCHER(digit);
CTYPE_SEQUENCE_MATCHER(xdigit);
CTYPE_SEQUENCE_MATCHER(alnum);
CTYPE_SEQUENCE_MATCHER(punct);
TO_EOL_MATCHER(line_comment, "//");
DELIMITED_MATCHER(block_comment, "/*", "*/", 0);
DELIMITED_MATCHER(double_quoted_string, "\"", "\"", 1);
DELIMITED_MATCHER(single_quoted_string, "\'", "\'", 1);
DELIMITED_MATCHER(interpolant, "#{", "}", 0);
CHAR_MATCHER (lparen, '(');
CHAR_MATCHER (rparen, ')');
CHAR_MATCHER (lbrack, '[');
CHAR_MATCHER (rbrack, ']');
CHAR_MATCHER (lbrace, '{');
CHAR_MATCHER (rbrace, '}');
CHAR_MATCHER (underscore, '_');
CHAR_MATCHER (hyphen, '-');
CHAR_MATCHER (semicolon, ';');
CHAR_MATCHER (colon, ':');
CHAR_MATCHER (period, '.');
CHAR_MATCHER (dot, '.');
CHAR_MATCHER (question, '?');
CHAR_MATCHER (exclamation, '!');
CHAR_MATCHER (tilde, '~');
CHAR_MATCHER (backquote, '`');
CHAR_MATCHER (quote, '\"');
CHAR_MATCHER (apostrophe, '\'');
CHAR_MATCHER (ampersand, '&');
CHAR_MATCHER (caret, '^');
CHAR_MATCHER (pipe, '|');
CHAR_MATCHER (slash, '/');
CHAR_MATCHER (backslash, '\\');
CHAR_MATCHER (asterisk, '*');
CHAR_MATCHER (star, '*');
CHAR_MATCHER (pound, '#');
CHAR_MATCHER (hash, '#');
CHAR_MATCHER (at, '@');
CHAR_MATCHER (plus, '+');
CHAR_MATCHER (minus, '-');
CHAR_MATCHER (times, '*');
CHAR_MATCHER (divide, '/');
CHAR_MATCHER (percent, '%');
CHAR_MATCHER (dollar, '$');
CHAR_MATCHER (gt, '>');
CHARS_MATCHER(gte, ">=");
CHAR_MATCHER (lt, '<');
CHARS_MATCHER(lte, "<=");
CHAR_MATCHER (eq, '=');
CHAR_MATCHER (assign, '=');
CHARS_MATCHER(equal, "==");
/* *** */
static OPTIONAL_MATCHER(optional_spaces, sass_prefix_is_spaces);
SEQUENCE_MATCHER(adjacent_to, sass_prefix_is_optional_spaces, sass_prefix_is_plus);
SEQUENCE_MATCHER(precedes, sass_prefix_is_optional_spaces, sass_prefix_is_tilde);
SEQUENCE_MATCHER(parent_of, sass_prefix_is_optional_spaces, sass_prefix_is_gt);
ALIAS_MATCHERS(sass_prefix_is_spaces, ancestor_of);
/* CSS identifiers */
static OPTIONAL_MATCHER(optional_hyphen, sass_prefix_is_hyphen);
static ALTERNATIVES_MATCHER(nmstart, sass_prefix_is_alphas, sass_prefix_is_underscore);
static ALTERNATIVES_MATCHER(nmchar, sass_prefix_is_alnums, sass_prefix_is_underscore, sass_prefix_is_hyphen);
static ZERO_PLUS_MATCHER(nmchars, sass_prefix_is_nmchar);
SEQUENCE_MATCHER(ident, sass_prefix_is_optional_hyphen, sass_prefix_is_nmstart, sass_prefix_is_nmchars);
/* CSS numbers */
static CHAR_CLASS_MATCHER(sign, "-+");
static OPTIONAL_MATCHER(optional_sign, sass_prefix_is_sign);
static OPTIONAL_MATCHER(optional_digits, sass_prefix_is_digits);
static SEQUENCE_MATCHER(realnum, sass_prefix_is_optional_digits, sass_prefix_is_dot, sass_prefix_is_digits);
static ALTERNATIVES_MATCHER(signless_num, sass_prefix_is_realnum, sass_prefix_is_digits);
SEQUENCE_MATCHER(num, sass_prefix_is_optional_sign, sass_prefix_is_signless_num);
/* CSS strings (double and single quoted) */
ALTERNATIVES_MATCHER(string, sass_prefix_is_double_quoted_string, sass_prefix_is_single_quoted_string);
SEQUENCE_MATCHER(atkeyword, sass_prefix_is_at, sass_prefix_is_ident);
static ONE_PLUS_MATCHER(name, sass_prefix_is_nmchar);
SEQUENCE_MATCHER(idname, sass_prefix_is_hash, sass_prefix_is_name);
SEQUENCE_MATCHER(classname, sass_prefix_is_dot, sass_prefix_is_name);
SEQUENCE_MATCHER(percentage, sass_prefix_is_num, sass_prefix_is_percent);
SEQUENCE_MATCHER(dimension, sass_prefix_is_num, sass_prefix_is_ident);
static CHARS_MATCHER(url_call, "url(");
SEQUENCE_MATCHER(uri, sass_prefix_is_url_call,
sass_prefix_is_optional_spaces,
sass_prefix_is_string,
sass_prefix_is_optional_spaces,
sass_prefix_is_rparen);
SEQUENCE_MATCHER(function, sass_prefix_is_ident, sass_prefix_is_lparen);
CHAR_MATCHER (exactmatch, '=');
CHARS_MATCHER(includes, "~=");
CHARS_MATCHER(dashmatch, "|=");
CHARS_MATCHER(prefixmatch, "^=");
CHARS_MATCHER(suffixmatch, "$=");
CHARS_MATCHER(substringmatch, "*=");
SEQUENCE_MATCHER(variable, sass_prefix_is_dollar, sass_prefix_is_ident);
\ No newline at end of file
c/prefix.h deleted 100644 → 0
typedef char *(*sass_prefix_matcher)(char *);
#define DECLARE(name) \
char *sass_prefix_is_ ## name(char *)
#define DECLARE_ALIAS(name) \
sass_prefix_matcher sass_prefix_is_ ## name
#define ALIAS_MATCHERS(orig, new) \
sass_prefix_matcher sass_prefix_is_ ## new = &orig
#define CHAR_MATCHER(name, prefix) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_is_char(src, prefix); \
}
#define CHARS_MATCHER(name, prefix) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_is_chars(src, prefix); \
}
#define CHAR_CLASS_MATCHER(name, class) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_is_one_of(src, class); \
}
#define CHARS_CLASS_MATCHER(name, class) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_is_some_of(src, class); \
}
#define SINGLE_CTYPE_MATCHER(type) \
char *sass_prefix_is_ ## type(char *src) { \
return is ## type(*src) ? src+1 : NULL; \
}
#define CTYPE_SEQUENCE_MATCHER(type) \
char *sass_prefix_is_ ## type ## s(char *src) { \
char *p = src; \
while (is ## type(*p)) p++; \
return p == src ? NULL : p; \
}
#define TO_EOL_MATCHER(name, prefix) \
char *sass_prefix_is_ ## name(char *src) { \
if (!(src = sass_prefix_is_chars(src, prefix))) return NULL; \
while(*src && *src != '\n') src++; \
return src; \
}
#define DELIMITED_MATCHER(name, begin, end, escapable) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_is_delimited_by(src, begin, end, escapable); \
}
#define ALTERNATIVES_MATCHER(name, ...) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_alternatives(src, __VA_ARGS__); \
}
#define SEQUENCE_MATCHER(name, ...) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_sequence(src, __VA_ARGS__); \
}
#define OPTIONAL_MATCHER(name, matcher) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_optional(src, matcher); \
}
#define ZERO_PLUS_MATCHER(name, matcher) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_zero_plus(src, matcher); \
}
#define ONE_PLUS_MATCHER(name, matcher) \
char *sass_prefix_is_ ## name(char *src) { \
return sass_prefix_one_plus(src, matcher); \
}
#define FIRST_REST_MATCHER(name, first_matcher, rest_matcher) \
char *sass_prefix_is_ ## name(char *src) { \
if (src = first_matcher(src)) src = sass_prefix_zero_plus(src, rest_matcher); \
return src; \
}
char *sass_prefix_is_char(char *src, char pre);
char *sass_prefix_is_chars(char *src, char *pre);
char *sass_prefix_is_one_of(char *src, char *class);
char *sass_prefix_is_some_of(char *src, char *class);
char *sass_prefix_is_delimited_by(char *src, char *beg, char *end, int esc);
char *sass_prefix_epsilon(char *src);
char *sass_prefix_not(char *src, sass_prefix_matcher m);
char *_sass_prefix_alternatives(char *src, ...);
#define sass_prefix_alternatives(src, ...) _sass_prefix_alternatives(src, __VA_ARGS__, NULL)
char *_sass_prefix_sequence(char *src, ...);
#define sass_prefix_sequence(src, ...) _sass_prefix_sequence(src, __VA_ARGS__, NULL)
char *sass_prefix_optional(char *src, sass_prefix_matcher m);
char *sass_prefix_zero_plus(char *src, sass_prefix_matcher m);
char *sass_prefix_one_plus(char *src, sass_prefix_matcher m);
char *sass_prefix_find_first(char *src, sass_prefix_matcher m);
DECLARE(space);
DECLARE(alpha);
DECLARE(digit);
DECLARE(xdigit);
DECLARE(alnum);
DECLARE(punct);
DECLARE(spaces);
DECLARE(alphas);
DECLARE(digits);
DECLARE(xdigits);
DECLARE(alnums);
DECLARE(puncts);
DECLARE(shell_comment);
DECLARE(line_comment);
DECLARE(block_comment);
DECLARE(double_quoted_string);
DECLARE(single_quoted_string);
DECLARE(interpolant);
DECLARE(lparen);
DECLARE(rparen);
DECLARE(lbrack);
DECLARE(rbrack);
DECLARE(lbrace);
DECLARE(rbrace);
DECLARE(underscore);
DECLARE(hyphen);
DECLARE(semicolon);
DECLARE(colon);
DECLARE(period);
DECLARE(dot);
DECLARE(question);
DECLARE(exclamation);
DECLARE(tilde);
DECLARE(backquote);
DECLARE(quote);
DECLARE(apostrophe);
DECLARE(ampersand);
DECLARE(caret);
DECLARE(pipe);
DECLARE(slash);
DECLARE(backslash);
DECLARE(asterisk);
DECLARE(star);
DECLARE(pound);
DECLARE(hash);
DECLARE(plus);
DECLARE(minus);
DECLARE(times);
DECLARE(divide);
DECLARE(percent);
DECLARE(dollar);
DECLARE(gt);
DECLARE(gte);
DECLARE(lt);
DECLARE(lte);
DECLARE(eq);
DECLARE(assign);
DECLARE(equal);
DECLARE(exactmatch);
DECLARE(classmatch);
DECLARE(dashmatch);
DECLARE(prefixmatch);
DECLARE(suffixmatch);
DECLARE(substringmatch);
DECLARE(ident);
DECLARE(variable);
DECLARE(number);
DECLARE(string);
DECLARE(idname);
DECLARE(classname);
DECLARE(functional);
DECLARE(adjacent_to);
DECLARE(parent_of);
DECLARE(precedes);
DECLARE_ALIAS(ancestor_of);
c/sassc.c deleted 100644 → 0
#include "libsass.h"
#include <stdio.h>
int main(int argc, char **argv)
{
char *filename = argv[1];
char *output = sass_file_compile(filename, 0);
printf("%s", output);
return 0;
}
\ No newline at end of file
c/test_array.c deleted 100644 → 0
#include <stdio.h>
#include <stdlib.h>
#include "test_array.h"
DEFINE_SASS_ARRAY_OF(char);
int main() {
sass_char_array a = sass_make_char_array(4);
printf("%ld, %ld\n", a.length, a.capacity);
sass_char_array_push(&a, 'h');
sass_char_array_push(&a, 'e');
sass_char_array_push(&a, 'l');
sass_char_array_push(&a, 'l');
printf("%ld, %ld\n", a.length, a.capacity);
int i;
for (i = 0; i < a.length; i++) putchar(a.contents[i]);
putchar('\n');
sass_char_array_push(&a, 'o');
printf("%ld, %ld\n", a.length, a.capacity);
for (i = 0; i < a.length; i++) putchar(a.contents[i]);
putchar('\n');
sass_char_array b = sass_make_char_array(7);
sass_char_array_push(&a, ' ');
sass_char_array_push(&a, 'w');
sass_char_array_push(&a, 'o');
sass_char_array_push(&a, 'r');
sass_char_array_push(&a, 'l');
sass_char_array_push(&a, 'd');
sass_char_array_cat(&a, &b);
printf("%ld, %ld\n", a.length, a.capacity);
for (i = 0; i < a.length; i++) putchar(a.contents[i]);
putchar('\n');
return 0;
}
\ No newline at end of file
c/test_array.h deleted 100644 → 0
#include "array.h"
DECLARE_SASS_ARRAY_OF(char);
\ No newline at end of file
c/test_context.c deleted 100644 → 0
#include <stdio.h>
#include "context.h"
int main() {
sass_context *ctx = sass_make_context_from_file("chars.txt");
char *src = ctx->src;
printf("<READING FROM FILE>\n");
while (*src++) putchar(*src);
printf("<EOF>\n");
sass_context *ctx2 = sass_make_context_from_string(ctx->src);
char *src2 = ctx2->src;
printf("<READING FROM STRING>\n");
while (*src2++) putchar(*src2);
printf("<EOF>\n");
return 0;
}
\ No newline at end of file
c/test_file.c deleted 100644 → 0
#include <stdio.h>
#include "file.h"
int main() {
char *src = sass_read_file("chars.txt");
printf("<BEGINNING OF FILE>\n");
while (*src++) putchar(*src);
printf("<EOF>");
return 0;
}
\ No newline at end of file
c/test_prefix.c deleted 100644 → 0
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "prefix.h"
void print_slice(char *s, char *t) {
if (t) {
printf("succeeded with %ld characters:\t", t - s);
while (s < t) putchar(*s++);
putchar('\n');
}
else {
printf("failed\n");
}
}
#define test1(matcher, src) \
(printf("testing << %s >>\n", #matcher), print_slice(src, matcher(src)))
#define testn(matcher, src, ...) \
(printf("testing << %s >>\n", #matcher), print_slice(src, matcher(src, __VA_ARGS__)))
int main() {
char *spaces = " \t \t \v \r\n \n\nhello world";
char *dqstring = "\"blah blah \\\" blah\"";
char *sqstring = "'this \\'is\\' a \"string\" now' blah blah blah";
char *scomment = "# a shell-style comment";
char *bcomment = "/* this is a c comment \\*/ blah blah";
char *non_comment = "/* blah blah";
char *interpolant = "#{ this is an interpolant \\} blah blah";
char *words = "hello my name is aaron";
char *id1 = "_identifier123{blah bloo}";
char *non_id = "12non_ident_ifier_";
char *word2 = "-blah-bl+ah_bl12-34+1:foobar;";
char *non_word = "-12blah-bloo";
char *selector = "#foo > :first-child { color: #abcdef; }";
char *lcomment = "// blah blah blah // end\n blah blah";
char *id2 = "badec4669264hello";
char *integer1 = "3837483+3";
char *integer2 = "+294739-4";
char *integer3 = "-294729+1";
char *class = ".blah-blah_bloo112-blah+blee4 hello";
char *id = "#foo_bar-baz123-hux blee";
char *var = "$blah123-blah";
char *non_var = "$ hux";
test1(sass_prefix_is_spaces, spaces);
test1(sass_prefix_is_spaces, words);
testn(sass_prefix_is_char, words, 'h');
testn(sass_prefix_is_char, words, 'a');
testn(sass_prefix_is_chars, words, "hello");
testn(sass_prefix_is_chars, words, "hello world");
testn(sass_prefix_is_one_of, words, "abcdefgh");
testn(sass_prefix_is_one_of, words, "ijklmnop");
testn(sass_prefix_is_some_of, id1, "_deint");
testn(sass_prefix_is_some_of, id1, "abcd");
test1(sass_prefix_is_block_comment, bcomment);
test1(sass_prefix_is_block_comment, non_comment);
test1(sass_prefix_is_double_quoted_string, dqstring);
test1(sass_prefix_is_double_quoted_string, sqstring);
test1(sass_prefix_is_single_quoted_string, sqstring);
test1(sass_prefix_is_single_quoted_string, dqstring);
test1(sass_prefix_is_interpolant, interpolant);
test1(sass_prefix_is_interpolant, lcomment);
test1(sass_prefix_is_line_comment, lcomment);
test1(sass_prefix_is_line_comment, non_comment);
test1(sass_prefix_epsilon, words);
testn(sass_prefix_not, words, sass_prefix_is_puncts);
testn(sass_prefix_not, words, sass_prefix_is_alphas);
testn(sass_prefix_sequence, id2, sass_prefix_is_alphas, sass_prefix_is_digits);
testn(sass_prefix_sequence, id2, sass_prefix_is_alphas, sass_prefix_is_puncts);
testn(sass_prefix_optional, non_id, sass_prefix_is_digits);
testn(sass_prefix_optional, words, sass_prefix_is_digits);
testn(sass_prefix_zero_plus, words, sass_prefix_is_alphas);
testn(sass_prefix_zero_plus, non_id, sass_prefix_is_alphas);
testn(sass_prefix_one_plus, words, sass_prefix_is_alphas);
testn(sass_prefix_one_plus, non_id, sass_prefix_is_alphas);
test1(sass_prefix_is_classname, class);
test1(sass_prefix_is_classname, words);
test1(sass_prefix_is_idname, id);
test1(sass_prefix_is_idname, class);
test1(sass_prefix_is_variable, var);
test1(sass_prefix_is_variable, non_var);
printf("sizeof char is %ld\n", sizeof(char));
printf("sizeof ptr is %ld\n", sizeof(void *));
printf("sizeof int is %ld\n", sizeof(int));
return 0;
}
c/transforms.c deleted 100644 → 0
#include "transforms.h"
int sass_transform(sass_context *ctx) {
return 0;
}
\ No newline at end of file
c/transforms.h deleted 100644 → 0
#ifndef CONTEXT_HEADER
#include "context.h"
#endif
int sass_transform(sass_context *ctx);
\ No newline at end of file
c/tree.h deleted 100644 → 0
typedef struct {
char *value;
} sass_expression;
typedef struct {
char *value;
} sass_selector;
typedef struct {
char *value; // Strip out the #{} nonsense
int *indexes;
sass_expression **expressions;
} sass_property;
typedef struct {
sass_property *property;
sass_expression *expression;
} sass_declaration;
typedef struct {
sass_selector **selectors;
} sass_selector_group;
typedef struct {
sass_selector_group *selector;
struct sass_ruleset **rules;
sass_declaration **declarations;
} sass_ruleset;
typedef struct {
char *path; /* the full directory+filename of the source file */
char *src; /* CHEAAAAATTTTT */
sass_ruleset **rules;
} sass_document;
spec/benchmarks/large_empty.scss 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment