/*
findSplitOperator
@param ptr pointer to start of str
@return ptr to end of string if no non-subshell operator is found,
otherwise pointer to lowest precendencenon-subshell operator
*/
char *
findNextOperator(char *ptr, char *end) {
ptr=skipWs(ptr);
if (*ptr=='(') { //opening of subshell
int openparen=1;
while (openparen>0) {
ptr++;
char c=*ptr;
if (c == '(') {
openparen++;
} else if (c==')') {
openparen--;
}
}
}
char *op=strpbrk(ptr,";$*|");
return op;
}
/**
* Detect token Decimal number
* @param state
* @param token
* @return
*/
int scpiLex_DecimalNumericProgramData(lex_state_t * state, scpi_token_t * token) {
char * rollback;
token->ptr = state->pos;
if (skipMantisa(state)) {
rollback = state->pos;
skipWs(state);
if (!skipExponent(state)) {
state->pos = rollback;
}
} else {
state->pos = token->ptr;
}
token->len = state->pos - token->ptr;
if (token->len > 0) {
token->type = SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA;
} else {
token->type = SCPI_TOKEN_UNKNOWN;
}
return token->len;
}
static XmlElement *
parseElement(XmlDoc *doc, const char **xmlText, XmlElement *parent)
{
XmlElement *element = 0;
XmlElement *childnode = 0;
XmlAttribute *attribute = 0;
const char *startval = 0;
const char *endval = 0;
size_t valLen = 0;
++(*xmlText);
if (!**xmlText) FAIL(XML_EOF);
if (**xmlText == '/')
{
++(*xmlText);
FAILS(XML_CLOSEWOOPEN, readBareWord(xmlText, ">"));
}
element = calloc(1, sizeof(XmlElement));
element->prev = element->next = element;
element->parent = parent;
if (parent)
{
element->depth = parent->depth + 1;
}
else
{
element->depth = 0;
}
element->name = readBareWord(xmlText, ">");
if (!element->name) FAIL(XML_UNNAMEDTAG);
if (!**xmlText) FAIL(XML_EOF);
while (1)
{
skipWs(doc, xmlText);
if (!**xmlText) FAIL(XML_EOF);
if (**xmlText == '>')
{
++(*xmlText);
break;
}
if (**xmlText == '/')
{
++(*xmlText);
skipWs(doc, xmlText);
if (!**xmlText) FAIL(XML_EOF);
if (**xmlText != '>') FAILC(XML_UNEXPECTED, **xmlText);
++(*xmlText);
return element;
}
attribute = parseAttribute(doc, xmlText, element);
if (!attribute) goto failp;
if (element->attributes)
{
attribute->prev = element->attributes->prev;
attribute->next = element->attributes;
element->attributes->prev->next = attribute;
element->attributes->prev = attribute;
}
else
{
element->attributes = attribute;
}
attribute = 0;
if (!**xmlText) FAIL(XML_EOF);
}
startval = *xmlText;
while (**xmlText)
{
if (**xmlText == '<')
{
if (hasNonWs(startval, *xmlText))
{
endval = *xmlText;
while (isspace(*(endval-1))) --endval;
appendString(&(element->value), startval, &valLen,
(size_t)(endval - startval));
}
if ((*xmlText)[1] == '/')
{
*xmlText += 2;
skipWs(doc, xmlText);
if (!**xmlText) FAIL(XML_EOF);
if (strncmp(*xmlText, element->name, strlen(element->name)))
{
FAILS(XML_UNMATCHEDCLOSE, cloneString(element->name));
}
*xmlText += strlen(element->name);
skipWs(doc, xmlText);
if (!**xmlText) FAIL(XML_EOF);
if (**xmlText != '>') FAILC(XML_UNEXPECTED, **xmlText);
++(*xmlText);
return element;
}
else
{
childnode = parseElement(doc, xmlText, element);
if (!childnode) goto failp;
if (element->children)
{
childnode->prev = element->children->prev;
childnode->next = element->children;
element->children->prev->next = childnode;
element->children->prev = childnode;
}
else
{
element->children = childnode;
}
childnode = 0;
startval = *xmlText;
}
}
else skipUntil(doc, xmlText, '<');
}
doc->err = XML_EOF;
fail:
doc->col = *xmlText - doc->currLine + 1;
failp:
freeElementList(element);
return 0;
}
command_t
parseCmd(char *start, char *end) {
if (start>end/* || iters++>MAXITER*/) return NULL;
//trim the start and end pointers
start=skipWs(start);
if (*start=='\0') return NULL;
while (*end == ' ' || *end == '\t' || *end == '\n')
{
end--;
}
if (debug) printf("parsing: \"%.*s\" start = \'%c\' end = \'%c\'\n", end-start+1, start, *start, *end);
command_t t = (command_t) checked_malloc(sizeof(struct command));
char *ptr = start;
//char *op = findNextOperator(ptr);
char *op = strpbrk(skipSubshell(ptr), ";$*|");
char *next = op;
////printf("parsing: start = %c op = %c next = %c \n", *ptr, *op, *next);
while (next && next <= end) {
char * prec = ";$*|";
int opPrec = strchr(prec, *op) - prec;
int nextPrec = strchr(prec, *next) - prec;
//printf("parsing: [while] opPrec = %d nextPrec = %d \n", opPrec, nextPrec);
if (((opPrec == 1 || opPrec == 2) && (nextPrec == 1 || nextPrec == 2))
|| (nextPrec < opPrec))
{
op = next;
}
//printf("parsing: [while] start = %c op = %c next = %c \n", *ptr, *op, *next);
//next = findNextOperator(++next);
next = strpbrk(skipSubshell(++next), ";$*|");
}
if (op && op<end) { // if operator in expression
//////printf("op: %c\n",*op);
switch(*op) {
case ';':
t->type=SEQUENCE_COMMAND;
break;
case '$':
t->type=OR_COMMAND;
break;
case '*':
t->type=AND_COMMAND;
break;
case '|':
t->type=PIPE_COMMAND;
break;
default:
error(1,0,"illegal operator detected");
//should not get here
break;
}
//printf("\ncomplex command type%d: %.*s,%.*s\n", t->type, op-start, start,end-op,op+1);
//t->u.command=(command_t *) checked_malloc(sizeof(command_t)*2);
t->u.command[0]=parseCmd(start,op-1);
t->u.command[1]=parseCmd(op+1,end);
} else if (*start == '(') { //if subshell
//printf("subshell command\n");
ptr = skipSubshell(ptr);
t->type=SUBSHELL_COMMAND;
t->u.subshell_command=(command_t) checked_malloc(sizeof(command_t));
t->u.subshell_command=parseCmd(start+1,ptr-1);
} else { //simple command with no op and no subshell
//if (debug) printf("Building simple command\n");
t->type=SIMPLE_COMMAND;
int wdct=0;//word count tracker
//construct the simple command struct from str - check for redirections
char* s = start;
char* e;
while (s)
{
if(*s == '<')
{
s = nextWordStart(s, end);
e = currWordEnd(s, end);
size_t wsize = e-s+1;
t->input=(char *) checked_malloc(wsize+1);
memcpy(t->input,s,wsize);
t->input[wsize]='\0';
if(debug) printf("Building segments: \"%.*s\" -> \'%s\'\n", e-s+1, s, t->input);
}
else if(*s == '>')
{
s = nextWordStart(s, end);
e = currWordEnd(s, end);
size_t wsize = e-s+1;
t->output=(char *) checked_malloc(wsize+1);
memcpy(t->output,s,wsize);
t->output[wsize]='\0';
if(debug) printf("Building segments: \"%.*s\" -> \'%s\'\n", e-s+1, s, t->output);
}
else
{
e = currWordEnd(s, end);
size_t wsize = e-s+1;
size_t asize = sizeof(char*) * (wdct+2);
t->u.word = (char **) checked_realloc(t->u.word, asize);
t->u.word[wdct] = (char *) checked_malloc(wsize+1);
memcpy(t->u.word[wdct],s,wsize);
t->u.word[wdct][wsize]='\0';
wdct++;
if(debug) printf("Building segments: \"%.*s\" -> \'%s\'\n", e-s+1, s, t->u.word[wdct-1]);
}
s = nextWordStart(e, end);
}
*(t->u.word+wdct)=NULL;
}
return t;
}
static bool ParseSvgPathData(const char* s, VecSegmented<SvgPathInstr>& instr) {
s = skipWs(s);
while (*s) {
SvgPathInstr i(GetInstructionType(*s++));
switch (i.type) {
case PathInstr::Close:
case PathInstr::Close2:
break;
case PathInstr::HLineAbs:
case PathInstr::HLineRel:
case PathInstr::VLineAbs:
case PathInstr::VLineRel:
s = str::Parse(s, "%f", &i.v[0]);
break;
case PathInstr::MoveAbs:
case PathInstr::MoveRel:
case PathInstr::LineToAbs:
case PathInstr::LineToRel:
case PathInstr::BezierTAbs:
case PathInstr::BezierTRel:
s = str::Parse(s, "%f%_%?,%_%f", &i.v[0], &i.v[1]);
break;
case PathInstr::BezierSAbs:
case PathInstr::BezierSRel:
case PathInstr::BezierQAbs:
case PathInstr::BezierQRel:
s = str::Parse(s, "%f%_%?,%_%f,%f%_%?,%_%f", &i.v[0], &i.v[1], &i.v[2], &i.v[3]);
break;
case PathInstr::BezierCAbs:
case PathInstr::BezierCRel:
s = str::Parse(s, "%f%_%?,%_%f,%f%_%?,%_%f,%f%_%?,%_%f", &i.v[0], &i.v[1], &i.v[2], &i.v[3], &i.v[4],
&i.v[5]);
break;
case PathInstr::ArcAbs:
case PathInstr::ArcRel: {
int largeArc, sweep;
s = str::Parse(s, "%f%_%?,%_%f%_%?,%_%f%_%?,%_%d%_%?,%_%d%_%?,%_%f%_%?,%_%f", &i.v[0], &i.v[1], &i.v[2],
&largeArc, &sweep, &i.v[3], &i.v[4]);
i.largeArc = (largeArc != 0);
i.sweep = (sweep != 0);
} break;
default:
CrashIf(true);
return false;
}
if (!s) {
return false;
}
instr.Append(i);
s = skipWs(s);
}
return true;
}
