char_t *websUrlType(char_t *url, char_t *buf, int charCnt)
{
sym_t *sp;
char_t *ext, *parsebuf;
a_assert(url && *url);
a_assert(buf && charCnt > 0);
if (url == NULL || *url == '\0') {
gstrcpy(buf, T("text/plain"));
return buf;
}
if (websUrlParse(url, &parsebuf, NULL, NULL, NULL, NULL, NULL,
NULL, &ext) < 0) {
gstrcpy(buf, T("text/plain"));
return buf;
}
strlower(ext);
/*
* Lookup the mime type symbol table to find the relevant content type
*/
if ((sp = symLookup(websMime, ext)) != NULL) {
gstrncpy(buf, sp->content.value.string, charCnt);
} else {
gstrcpy(buf, T("text/plain"));
}
bfree(B_L, parsebuf);
return buf;
}
/*
* dereference macro ... return one of the DEREF_* values
* for DEREF_ERROR, error is reported here
*/
static int
varDeref(char *name)
{
Symbol s;
Expr *x;
LexIn *t;
/* lookup macro name */
if ((s = symLookup(&vars, name)) == NULL) {
fprintf(stderr, "undefined macro name $%s\n", name);
return DEREF_ERROR;
}
x = symValue(s);
/* string macro */
if (x->sem == SEM_CHAR) {
t = (LexIn *) zalloc(sizeof(LexIn));
t->prev = lin;
lin = t;
lin->name = (char *) alloc(strlen(name) + 1);
strcpy(lin->name, name);
lin->macro = (char *) x->ring;
lin->lno = 1;
lin->cno = 0;
return DEREF_STRING;
}
/* boolean valued macro */
if (x->sem == SEM_BOOLEAN) {
yylval.x = x;
return DEREF_BOOL;
}
/* constant numeric valued macro */
if (x->sem == SEM_NUMCONST) {
/*
* need to copy the Expr as the one returned here may be freed
* later after constant folding, and we need the real macro's
* value to be available for use in later rules
*/
yylval.x = newExpr(NOP, NULL, NULL, -1, -1, -1, 1, SEM_NUMCONST);
yylval.x->smpls[0].ptr = x->smpls[0].ptr;
yylval.x->valid = 1;
return DEREF_NUMBER;
}
/* variable numeric valued macro */
if (x->sem == SEM_NUMVAR) {
yylval.x = x;
return DEREF_NUMBER;
}
fprintf(stderr, "varDeref(%s): internal botch sem=%d?\n", name, x->sem);
dumpExpr(x);
exit(1);
}
int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path, char_t *query)
{
sym_t *sp;
char_t formBuf[FNAMESIZE];
char_t *cp, *formName;
int (*fn)(void *sock, char_t *path, char_t *args);
a_assert(websValid(wp));
a_assert(url && *url);
a_assert(path && *path == '/');
websStats.formHits++;
/*
* Extract the form name
*/
gstrncpy(formBuf, path, TSZ(formBuf));
if ((formName = gstrchr(&formBuf[1], '/')) == NULL) {
websError(wp, 200, T("Missing form name"));
return 1;
}
formName++;
if ((cp = gstrchr(formName, '/')) != NULL) {
*cp = '\0';
}
/*
* Lookup the C form function first and then try tcl (no javascript support
* yet).
*/
sp = symLookup(formSymtab, formName);
if (sp == NULL) {
websError(wp, 200, T("Form %s is not defined"), formName);
} else {
fn = (int (*)(void *, char_t *, char_t *)) sp->content.value.integer;
a_assert(fn);
if (fn) {
/*
* For good practice, forms must call websDone()
*/
(*fn)((void*) wp, formName, query);
/*
* Remove the test to force websDone, since this prevents
* the server "push" from a form>
*/
#if 0 /* push */
if (websValid(wp)) {
websError(wp, 200, T("Form didn't call websDone"));
}
#endif /* push */
}
}
return 1;
}
/* statement */
Symbol
statement(char *name, Expr *x)
{
Symbol s;
/* error guard */
if (x == NULL) return NULL;
/* if name not given, make one up */
if (name == NULL) name = nameGen();
/* the parsed object is a rule (expression to evaluate) */
if (x->op != NOP) {
if (symLookup(&rules, name)) {
synerr();
fprintf(stderr, "rule \"%s\" multiply defined\n", name);
freeExpr(x);
return NULL;
}
else {
if (errs == 0) {
postExpr(x);
s = symIntern(&rules, name);
}
else return NULL;
}
}
/* the parsed object is a non-rule */
else {
if ( (s = symLookup(&vars, name)) )
freeExpr(symValue(s));
else
s = symIntern(&vars, name);
}
symValue(s) = x;
return s;
}
int websRomPageOpen(webs_t wp, char_t *path, int mode, int perm)
{
websRomPageIndexType *wip;
sym_t *sp;
a_assert(websValid(wp));
a_assert(path && *path);
if ((sp = symLookup(romTab, path)) == NULL) {
return -1;
}
wip = (websRomPageIndexType*) sp->content.value.integer;
wip->pos = 0;
return (wp->docfd = wip - websRomPageIndex);
}
int websRomPageStat(char_t *path, websStatType *sbuf)
{
websRomPageIndexType *wip;
sym_t *sp;
a_assert(path && *path);
if ((sp = symLookup(romTab, path)) == NULL) {
return -1;
}
wip = (websRomPageIndexType*) sp->content.value.integer;
memset(sbuf, 0, sizeof(websStatType));
sbuf->size = wip->size;
if (wip->page == NULL) {
sbuf->isDir = 1;
}
return 0;
}
static ast* parseLet (parserCtx* ctx) {
match(ctx, "let");
sym* symbol = 0;
if (see_kind(ctx, tokenNormal)) {
/*Name collision*/
if (symLookup(ctx->scope, ctx->current.buffer))
/*Error, but use the given name anyway*/
error(ctx)("Symbol named '%s' already declared\n", ctx->current.buffer);
symbol = symAdd(ctx->scope, ctx->current.buffer);
accept(ctx);
} else
expected(ctx, "variable name");
match(ctx, "=");
ast* init = parseExpr(ctx);
return astCreateLet(symbol, init);
}
/**
* Atom = ( "(" [ Expr [{ "," Expr }] ] ")" )
* | ( "[" [{ Expr }] "]" )
* | FnLit | Path | <Str> | <Symbol>
*/
static ast* parseAtom (parserCtx* ctx) {
ast* node;
if (try_match(ctx, "(")) {
/*Empty brackets => unit literal*/
if (see(ctx, ")"))
node = astCreateUnitLit();
else {
node = parseExpr(ctx);
/*Tuple literal*/
if (see(ctx, ",")) {
vector(ast*) nodes = vectorInit(3, malloc);
vectorPush(&nodes, node);
while (try_match(ctx, ","))
vectorPush(&nodes, parseExpr(ctx));
node = astCreateTupleLit(nodes);
}
}
match(ctx, ")");
/*List literal*/
} else if (try_match(ctx, "[")) {
vector(ast*) nodes = vectorInit(4, malloc);
if (waiting_for(ctx, "]")) do {
vectorPush(&nodes, parseExpr(ctx));
} while (try_match(ctx, ","));
node = astCreateListLit(nodes);
match(ctx, "]");
} else if (see(ctx, "\\")) {
node = parseFnLit(ctx);
} else if (see(ctx, "true") || see(ctx, "false")) {
node = astCreateBoolLit(see(ctx, "true"));
accept(ctx);
} else if (see_kind(ctx, tokenIntLit)) {
node = astCreateIntLit(atoi(ctx->current.buffer));
accept(ctx);
} else if (see_kind(ctx, tokenStrLit)) {
node = astCreateStrLit(ctx->current.buffer);
accept(ctx);
} else if (see_kind(ctx, tokenNormal)) {
sym* symbol;
if (isPathToken(ctx->current.buffer))
node = parsePath(ctx);
else if ((symbol = symLookup(ctx->scope, ctx->current.buffer)))
node = astCreateSymbol(symbol);
else
node = astCreateFileLit(ctx->current.buffer);
accept(ctx);
} else {
expected(ctx, "expression");
node = astCreateInvalid();
}
return node;
}
