You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
479 rivejä
11 KiB
479 rivejä
11 KiB
%{
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "inputBuffer.c"
|
|
;
|
|
enum op { String, Query, Star, Plus, Or, And, Class, Dot, Exc, Id } ;
|
|
|
|
|
|
typedef union Node Node;
|
|
typedef struct Symbol Symbol;
|
|
typedef struct Array Array;
|
|
typedef struct SymbolTable SymbolTable;
|
|
struct Array {
|
|
Node **elements;
|
|
int length;
|
|
};
|
|
|
|
struct String { enum op type; char *string; int len; };
|
|
struct Query { enum op type; Node *children[1]; };
|
|
struct Star { enum op type; Node *children[1]; };
|
|
struct Plus { enum op type; Node *children[1]; };
|
|
struct Or { enum op type; Node *children[2]; };
|
|
struct And { enum op type; Node *children[2]; };
|
|
struct Class { enum op type; char *stringValue; int len; };
|
|
struct Dot { enum op type; };
|
|
struct Exc { enum op type; Node *children[1]; };
|
|
struct Id { enum op type; Symbol *symbol; };
|
|
|
|
union Node {
|
|
enum op type;
|
|
struct String String;
|
|
struct Query Query;
|
|
struct Star Star;
|
|
struct Plus Plus;
|
|
struct Or Or;
|
|
struct And And;
|
|
struct Class Class;
|
|
struct Dot Dot;
|
|
struct Exc Exc;
|
|
struct Id Id;
|
|
};
|
|
|
|
struct Symbol{
|
|
char* name;
|
|
Node *rule;
|
|
};
|
|
|
|
struct SymbolTable {
|
|
Symbol **elements;
|
|
int length;
|
|
};
|
|
|
|
#define SymbolTable_initialiser {0,0}
|
|
SymbolTable symbolTable= SymbolTable_initialiser;
|
|
|
|
Symbol *createSymbol(char *name) {
|
|
Symbol *symbol= calloc(1, sizeof(Symbol));
|
|
symbol->name= strdup(name);
|
|
return symbol;
|
|
}
|
|
|
|
|
|
|
|
|
|
#define new(type) mkNode(sizeof(struct type),type)
|
|
|
|
Node *mkNode(size_t size,enum op type)
|
|
{
|
|
Node *node= calloc(1, size);
|
|
node->type= type;
|
|
return node;
|
|
}
|
|
|
|
Node *mkString(char *s)
|
|
{
|
|
Node *node= new(String);
|
|
node->String.string= strdup(s);
|
|
node->String.len=strlen(s);
|
|
return node;
|
|
}
|
|
|
|
Node *mkId(char *s){
|
|
|
|
Node *node= new(Id);
|
|
node->Id.symbol=createSymbol(s);
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
Node *mkQuery(Node *n)
|
|
{
|
|
Node *node= new(Query);
|
|
node->Query.children[0]= n;
|
|
return node;
|
|
}
|
|
|
|
Node *mkOr(Node *node1, Node *node2)
|
|
{
|
|
Node *node= new(Or);
|
|
node->Or.children[0]= node1;
|
|
node->Or.children[1]= node2;
|
|
return node;
|
|
}
|
|
|
|
Node *mkAnd(Node *node1, Node *node2)
|
|
{
|
|
Node *node= new(And);
|
|
node->And.children[0]= node1;
|
|
node->And.children[1]= node2;
|
|
return node;
|
|
}
|
|
|
|
Node *mkStar(Node *n)
|
|
{
|
|
Node *node= new(Star);
|
|
node->Star.children[0]= n;
|
|
return node;
|
|
}
|
|
|
|
Node *mkClass(char* str)
|
|
{
|
|
Node *node= new(Class);
|
|
node->Class.stringValue= str;
|
|
node->Class.len=strlen(str);
|
|
return node;
|
|
}
|
|
|
|
Node *mkPlus(Node *n)
|
|
{
|
|
Node *node= new(Plus);
|
|
node->Plus.children[0]= n;
|
|
return node;
|
|
}
|
|
|
|
Node *mkDot()
|
|
{
|
|
Node *node= new(Dot);
|
|
return node;
|
|
}
|
|
|
|
Node *mkExc(Node *n)
|
|
{
|
|
Node *node= new(Exc);
|
|
node->Exc.children[0]= n;
|
|
return node;
|
|
}
|
|
|
|
Node *_checktype(Node *object, enum op type)
|
|
{
|
|
if (object->type == type) return object;
|
|
fprintf(stderr, "\naccesing type %i as if it were a %i\n", object->type, type);
|
|
exit(1);
|
|
return 0;
|
|
}
|
|
|
|
#define get(object, type, member) (_checktype(object, type)->type.member)
|
|
|
|
void print(Node *node)
|
|
{
|
|
switch (node->type) {
|
|
case String:
|
|
printf("\"%s\"", node->String.string);
|
|
return;
|
|
case Query:
|
|
print(node->Query.children[0]);
|
|
printf("?");
|
|
return;
|
|
case Star:
|
|
print(node->Query.children[0]);
|
|
printf("*");
|
|
return;
|
|
case Plus:
|
|
print(node->Query.children[0]);
|
|
return;
|
|
case Or:
|
|
print(node->Or.children[0]);
|
|
printf("Or");
|
|
print(node->Or.children[1]);
|
|
return;
|
|
case And:
|
|
print(node->And.children[0]);
|
|
printf("And");
|
|
print(node->And.children[1]);
|
|
return;
|
|
case Class:
|
|
printf("Class");
|
|
printf("\"%s\"", node->Class.stringValue);
|
|
return;
|
|
case Dot:
|
|
printf("Dot");
|
|
return;
|
|
case Exc:
|
|
printf("!");
|
|
print(node->Exc.children[0]);
|
|
return;
|
|
case Id:
|
|
printf("%s\n",get(node,Id,symbol)->name);
|
|
return;
|
|
}
|
|
abort();
|
|
}
|
|
|
|
void println(Node *node)
|
|
{
|
|
print(node);
|
|
printf("\n");
|
|
}
|
|
InputBuffer *inputBuffer=0;
|
|
|
|
#define YY_INPUT(buff,result,maxSize) \
|
|
{if (atEnd(inputBuffer)){ \
|
|
result=0; \
|
|
} \
|
|
else { \
|
|
*buff=currentChar(inputBuffer); \
|
|
advance(inputBuffer,1); \
|
|
result=1; \
|
|
}}
|
|
|
|
|
|
|
|
void move(SymbolTable *symbolTable, int a) {
|
|
symbolTable->length++;
|
|
symbolTable->elements= realloc(symbolTable->elements,sizeof(Node*) * symbolTable->length);
|
|
printf("begin\n");
|
|
for (int i= symbolTable->length-1; i >a; i--) {
|
|
symbolTable->elements[i] = symbolTable->elements[i-1];
|
|
printf("\n");
|
|
for(int i= 0; i<symbolTable->length; i++) {
|
|
printf("number : %i, name : %s, value : a\n",i, symbolTable->elements[i]->name);
|
|
}
|
|
}
|
|
printf("end\n");
|
|
}
|
|
|
|
void addSymbolSorted(SymbolTable *symbolTable, Symbol *symbol) {
|
|
int a=0;
|
|
int b= symbolTable->length-1;
|
|
int c;
|
|
//1 <b-a => no infinite loop with a and c = 0 et b =1
|
|
while (1 < b - a ) {
|
|
c= (a+b)/2;
|
|
if (strcmp(symbolTable->elements[c]->name, symbol->name) < 0) {
|
|
a= c;
|
|
} else {
|
|
b= c;
|
|
}
|
|
}
|
|
//b>-1 <=> symboleTable->length > 0
|
|
// this if is here to know if we put the symbol before or after a
|
|
if (b>-1 && strcmp(symbolTable->elements[a]->name, symbol->name) < 0) {
|
|
a++;
|
|
}
|
|
//we move all the symbols after a
|
|
move(symbolTable, a);
|
|
//we put the symbol at the right place
|
|
symbolTable->elements[a]->name = symbol->name;
|
|
}
|
|
|
|
int findSymbol(SymbolTable *symbolTable, char *name) {
|
|
for (int i= 0; i < symbolTable->length;i++) {
|
|
if (strcmp(symbolTable->elements[i]->name, name) == 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
Symbol *symbol = createSymbol(name);
|
|
addSymbolSorted(symbolTable, symbol);
|
|
return 0;
|
|
}
|
|
|
|
Node *findSymbolSorted(SymbolTable *symbolTable, char *name) {
|
|
int a=0;
|
|
int b= symbolTable->length-1;
|
|
int c;
|
|
//1 <b-a => no infinite loop with a and c = 0 et b =1
|
|
while (1 < b - a ) {
|
|
c= (a+b)/2;
|
|
if (strcmp(symbolTable->elements[c]->name, name) < 0) {
|
|
a= c;
|
|
} else {
|
|
if (strcmp(symbolTable->elements[c]->name, name) > 0) {
|
|
b= c;
|
|
} else {
|
|
return symbolTable->elements[c]->rule;
|
|
}
|
|
}
|
|
}
|
|
//b>-1 <=> symboleTable->length > 0
|
|
// this if is here to know if we put the symbol before or after a
|
|
if (b>-1 && strcmp(symbolTable->elements[a]->name, name) < 0) {
|
|
a++;
|
|
}
|
|
//we move all the symbols after a
|
|
move(symbolTable, a);
|
|
//we put the symbol at the right place
|
|
symbolTable->elements[a]= createSymbol(name);
|
|
return 0;
|
|
}
|
|
|
|
void setRule(SymbolTable *symbolTable, char *name, Node *rule) {
|
|
for (int i= 0; i < symbolTable->length;i++) {
|
|
if (strcmp(symbolTable->elements[i]->name, name) == 0) {
|
|
symbolTable->elements[i]->rule= rule;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void arrayAppend(Array *array, Node *statement) {
|
|
array->length++;
|
|
array->elements= realloc(array->elements,sizeof(Node*) * array->length);
|
|
array->elements[array->length-1] = statement;
|
|
}
|
|
|
|
|
|
#define YYSTYPE Node *
|
|
YYSTYPE yylval = 0;
|
|
|
|
%}
|
|
|
|
start = declaration+
|
|
|
|
declaration = i:id '=' - e:expression { setRule(&symbolTable,get(i, Id, symbol)->name, e) }
|
|
|
|
or = a:and - "|" - o:or {$$ = mkOr(o, a) }
|
|
| a:and { $$ = a }
|
|
|
|
and = p:prefix a:and { $$ = mkAnd(p, a); }
|
|
| p:prefix { $$ = p }
|
|
|
|
prefix = "!"- p : postfix {$$ = mkExc(p)}
|
|
| p: postfix {$$ = p}
|
|
|
|
postfix = s:atom ( "?" - { s = mkQuery(s) }
|
|
| "*" - { s = mkStar(s) }
|
|
| "+" - { s = mkPlus(s) }
|
|
)? { $$ = s}
|
|
|
|
atom = string | class | dot | rule
|
|
|
|
rule = i:id !'=' { $$ = mkId(yytext) }
|
|
|
|
id = < [a-zA-z_][a-zA-z_0-9]* > - { $$ = mkId(yytext) }
|
|
|
|
string = '"' < [^"]* > '"' { $$ = mkString(yytext) } -
|
|
|
|
class = '['-<(!']'string)*> ']' { $$=mkClass(yytext) } -
|
|
|
|
dot = -'.'- {$$=mkDot()} -
|
|
|
|
|
|
- = space*
|
|
|
|
space = [ \t] | '\n' '\r'* | '\r' '\n'*
|
|
|
|
%%
|
|
|
|
|
|
|
|
|
|
|
|
int execute(Node *node, InputBuffer *in)
|
|
{
|
|
switch (node->type) {
|
|
case String: {
|
|
if (strncmp(currentText(in), get(node,String,string), get(node,String,len))) {
|
|
return 0;
|
|
}
|
|
advance(in, get(node,String,len));
|
|
return 1;
|
|
}
|
|
case And: {
|
|
int pos= getPosition(in);
|
|
if (!execute(get(node,And,children[0]), in)) //si il y a eu une erreur
|
|
{
|
|
return 0;
|
|
} //si ça s'est bien passé
|
|
if (!execute(get(node,And,children[1]), in)) {
|
|
setPosition(in, pos);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
case Or: {
|
|
if (execute(get(node,Or,children[0]), in)) {
|
|
return 1;
|
|
}
|
|
return execute(get(node,Or,children[1]), in);
|
|
}
|
|
case Star: {
|
|
while (execute(get(node,Star,children[0]), in));
|
|
return 1;
|
|
}
|
|
case Plus: {
|
|
if (!execute(get(node,Plus,children[0]), in)) {
|
|
return 0;
|
|
}
|
|
while (execute(get(node,Plus,children[0]), in));
|
|
return 1;
|
|
}
|
|
case Class: {
|
|
if (!currentChar(in)) {
|
|
return 0;
|
|
}
|
|
if (strchr(get(node,Class,stringValue), currentChar(in))) {
|
|
advance(in, 1);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
case Query: {
|
|
execute(get(node,Query,children[0]), in);
|
|
return 1;
|
|
}
|
|
case Exc: {
|
|
int pos= getPosition(in);
|
|
if (!execute(get(node,Exc,children[0]), in)) {
|
|
return 1;
|
|
}
|
|
setPosition(in, pos);
|
|
return 0;
|
|
}
|
|
case Dot: {
|
|
if (atEnd(in)) {
|
|
return 0;
|
|
}
|
|
advance(in, 1);
|
|
return 1;
|
|
}
|
|
case Id: {
|
|
Symbol *symbol= get(node, Id, symbol);
|
|
return execute(symbol->rule, in);
|
|
}
|
|
}
|
|
printf("this cannot happen\n");
|
|
abort();
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
if(argc<2) return 0;
|
|
|
|
inputBuffer = mkInputBuffer(argv[1]);
|
|
|
|
if (!yyparse()) {
|
|
printf("Error\n");
|
|
return 1;
|
|
}
|
|
println(yylval);
|
|
char *line=0;
|
|
size_t line_max=0;
|
|
ssize_t line_len=0;
|
|
while((line_len=getline(&line,&line_max,stdin))>=0){
|
|
if(line_len>0 && line[line_len-1]=='\n'){
|
|
line[line_len-1]=0;
|
|
}
|
|
initInputBuffer(inputBuffer,line);
|
|
if (!execute(yylval, inputBuffer) || !atEnd(inputBuffer)){
|
|
printf("no match, current position : %i\n", getPosition(inputBuffer));
|
|
}
|
|
else{
|
|
printf("match, current position : %i\n", getPosition(inputBuffer));
|
|
}// 0 => no match, 1 => match
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
(void)yySet;
|
|
(void)yyPop;
|
|
(void)yyPush;
|
|
(void)yyAccept;
|
|
(void)yymatchDot;
|
|
(void)yymatchString;
|
|
(void)yymatchChar;
|
|
}
|