Пример #1
0
/* Parse a variable assignment line */
static int parse_line(const char* unit,
                      const char *filename,
                      unsigned line,
                      const char *sections,
                      ConfigItemLookup lookup,
                      const void *table,
                      bool relaxed,
                      bool allow_include,
                      char **section,
                      unsigned *section_line,
                      bool *section_ignored,
                      char *l,
                      void *userdata) {

    char *e;

    assert(filename);
    assert(line > 0);
    assert(lookup);
    assert(l);

    l = strstrip(l);

    if (!*l)
        return 0;

    if (strchr(COMMENTS "\n", *l))
        return 0;

    if (startswith(l, ".include ")) {
        _cleanup_free_ char *fn = NULL;

        /* .includes are a bad idea, we only support them here
         * for historical reasons. They create cyclic include
         * problems and make it difficult to detect
         * configuration file changes with an easy
         * stat(). Better approaches, such as .d/ drop-in
         * snippets exist.
         *
         * Support for them should be eventually removed. */

        if (!allow_include) {
            log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
                       ".include not allowed here. Ignoring.");
            return 0;
        }

        fn = file_in_same_dir(filename, strstrip(l+9));
        if (!fn)
            return -ENOMEM;

        return config_parse(unit, fn, NULL, sections, lookup, table, relaxed, false, false, userdata);
    }

    if (*l == '[') {
        size_t k;
        char *n;

        k = strlen(l);
        assert(k > 0);

        if (l[k-1] != ']') {
            log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
                       "Invalid section header '%s'", l);
            return -EBADMSG;
        }

        n = strndup(l+1, k-2);
        if (!n)
            return -ENOMEM;

        if (sections && !nulstr_contains(sections, n)) {

            if (!relaxed && !startswith(n, "X-"))
                log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
                           "Unknown section '%s'. Ignoring.", n);

            free(n);
            free(*section);
            *section = NULL;
            *section_line = 0;
            *section_ignored = true;
        } else {
            free(*section);
            *section = n;
            *section_line = line;
            *section_ignored = false;
        }

        return 0;
    }

    if (sections && !*section) {

        if (!relaxed && !*section_ignored)
            log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
                       "Assignment outside of section. Ignoring.");

        return 0;
    }

    e = strchr(l, '=');
    if (!e) {
        log_syntax(unit, LOG_WARNING, filename, line, EINVAL, "Missing '='.");
        return -EBADMSG;
    }

    *e = 0;
    e++;

    return next_assignment(unit,
                           filename,
                           line,
                           lookup,
                           table,
                           *section,
                           *section_line,
                           strstrip(l),
                           strstrip(e),
                           relaxed,
                           userdata);
}
Пример #2
0
/* Parse a variable assignment line */
static int parse_line(const char* unit,
                      const char *filename,
                      unsigned line,
                      const char *sections,
                      ConfigItemLookup lookup,
                      void *table,
                      bool relaxed,
                      bool allow_include,
                      char **section,
                      unsigned *section_line,
                      char *l,
                      void *userdata) {

        char *e;

        assert(filename);
        assert(line > 0);
        assert(lookup);
        assert(l);

        l = strstrip(l);

        if (!*l)
                return 0;

        if (strchr(COMMENTS "\n", *l))
                return 0;

        if (startswith(l, ".include ")) {
                _cleanup_free_ char *fn = NULL;

                if (!allow_include) {
                        log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
                                   ".include not allowed here. Ignoring.");
                        return 0;
                }

                fn = file_in_same_dir(filename, strstrip(l+9));
                if (!fn)
                        return -ENOMEM;

                return config_parse(unit, fn, NULL, sections, lookup, table, relaxed, false, userdata);
        }

        if (*l == '[') {
                size_t k;
                char *n;

                k = strlen(l);
                assert(k > 0);

                if (l[k-1] != ']') {
                        log_syntax(unit, LOG_ERR, filename, line, EBADMSG,
                                   "Invalid section header '%s'", l);
                        return -EBADMSG;
                }

                n = strndup(l+1, k-2);
                if (!n)
                        return -ENOMEM;

                if (sections && !nulstr_contains(sections, n)) {

                        if (!relaxed)
                                log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
                                           "Unknown section '%s'. Ignoring.", n);

                        free(n);
                        free(*section);
                        *section = NULL;
                        *section_line = 0;
                } else {
                        free(*section);
                        *section = n;
                        *section_line = line;
                }

                return 0;
        }

        if (sections && !*section) {

                if (!relaxed)
                        log_syntax(unit, LOG_WARNING, filename, line, EINVAL,
                                   "Assignment outside of section. Ignoring.");

                return 0;
        }

        e = strchr(l, '=');
        if (!e) {
                log_syntax(unit, LOG_WARNING, filename, line, EINVAL, "Missing '='.");
                return -EBADMSG;
        }

        *e = 0;
        e++;

        return next_assignment(unit,
                               filename,
                               line,
                               lookup,
                               table,
                               *section,
                               *section_line,
                               strstrip(l),
                               strstrip(e),
                               relaxed,
                               userdata);
}
Пример #3
0
/* Parse a variable assignment line */
static int parse_line(
                const char *filename,
                unsigned line,
                const char *sections,
                ConfigItemLookup lookup,
                void *table,
                bool relaxed,
                char **section,
                char *l,
                void *userdata) {

        char *e;

        assert(filename);
        assert(line > 0);
        assert(lookup);
        assert(l);

        l = strstrip(l);

        if (!*l)
                return 0;

        if (strchr(COMMENTS, *l))
                return 0;

        if (startswith(l, ".include ")) {
                char *fn;
                int r;

                fn = file_in_same_dir(filename, strstrip(l+9));
                if (!fn)
                        return -ENOMEM;

                r = config_parse(fn, NULL, sections, lookup, table, relaxed, userdata);
                free(fn);

                return r;
        }

        if (*l == '[') {
                size_t k;
                char *n;

                k = strlen(l);
                assert(k > 0);

                if (l[k-1] != ']') {
                        log_error("[%s:%u] Invalid section header.", filename, line);
                        return -EBADMSG;
                }

                n = strndup(l+1, k-2);
                if (!n)
                        return -ENOMEM;

                if (sections && !nulstr_contains(sections, n)) {

                        if (!relaxed)
                                log_info("[%s:%u] Unknown section '%s'. Ignoring.", filename, line, n);

                        free(n);
                        *section = NULL;
                } else {
                        free(*section);
                        *section = n;
                }

                return 0;
        }

        if (sections && !*section) {

                if (!relaxed)
                        log_info("[%s:%u] Assignment outside of section. Ignoring.", filename, line);

                return 0;
        }

        e = strchr(l, '=');
        if (!e) {
                log_error("[%s:%u] Missing '='.", filename, line);
                return -EBADMSG;
        }

        *e = 0;
        e++;

        return next_assignment(
                        filename,
                        line,
                        lookup,
                        table,
                        *section,
                        strstrip(l),
                        strstrip(e),
                        relaxed,
                        userdata);
}
Пример #4
0
/* Parse a single logical line */
static int parse_line(
                const char* unit,
                const char *filename,
                unsigned line,
                const char *sections,
                ConfigItemLookup lookup,
                const void *table,
                ConfigParseFlags flags,
                char **section,
                unsigned *section_line,
                bool *section_ignored,
                char *l,
                void *userdata) {

        char *e, *include;

        assert(filename);
        assert(line > 0);
        assert(lookup);
        assert(l);

        l = strstrip(l);
        if (!*l)
                return 0;

        if (strchr(COMMENTS "\n", *l))
                return 0;

        include = first_word(l, ".include");
        if (include) {
                _cleanup_free_ char *fn = NULL;

                /* .includes are a bad idea, we only support them here
                 * for historical reasons. They create cyclic include
                 * problems and make it difficult to detect
                 * configuration file changes with an easy
                 * stat(). Better approaches, such as .d/ drop-in
                 * snippets exist.
                 *
                 * Support for them should be eventually removed. */

                if (!(flags & CONFIG_PARSE_ALLOW_INCLUDE)) {
                        log_syntax(unit, LOG_ERR, filename, line, 0, ".include not allowed here. Ignoring.");
                        return 0;
                }

                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           ".include directives are deprecated, and support for them will be removed in a future version of systemd. "
                           "Please use drop-in files instead.");

                fn = file_in_same_dir(filename, strstrip(include));
                if (!fn)
                        return -ENOMEM;

                return config_parse(unit, fn, NULL, sections, lookup, table, flags, userdata);
        }

        if (!utf8_is_valid(l))
                return log_syntax_invalid_utf8(unit, LOG_WARNING, filename, line, l);

        if (*l == '[') {
                size_t k;
                char *n;

                k = strlen(l);
                assert(k > 0);

                if (l[k-1] != ']') {
                        log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid section header '%s'", l);
                        return -EBADMSG;
                }

                n = strndup(l+1, k-2);
                if (!n)
                        return -ENOMEM;

                if (sections && !nulstr_contains(sections, n)) {

                        if (!(flags & CONFIG_PARSE_RELAXED) && !startswith(n, "X-"))
                                log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown section '%s'. Ignoring.", n);

                        free(n);
                        *section = mfree(*section);
                        *section_line = 0;
                        *section_ignored = true;
                } else {
                        free_and_replace(*section, n);
                        *section_line = line;
                        *section_ignored = false;
                }

                return 0;
        }

        if (sections && !*section) {

                if (!(flags & CONFIG_PARSE_RELAXED) && !*section_ignored)
                        log_syntax(unit, LOG_WARNING, filename, line, 0, "Assignment outside of section. Ignoring.");

                return 0;
        }

        e = strchr(l, '=');
        if (!e) {
                log_syntax(unit, LOG_WARNING, filename, line, 0, "Missing '='.");
                return -EINVAL;
        }

        *e = 0;
        e++;

        return next_assignment(unit,
                               filename,
                               line,
                               lookup,
                               table,
                               *section,
                               *section_line,
                               strstrip(l),
                               strstrip(e),
                               flags,
                               userdata);
}
Пример #5
0
static list expandtransition(struct trans_object *trans_el, struct net_object *net, struct net_object *unf_net)
{
  struct trans_object *unf_trans;
  bool Found;
  struct lisp_object *lisp;
  struct arc_object *arc, *new_arc, *prev_arc;
  guard_exprPTR g;  
  arcPTR *parsedArcs;
  operandPTR op;
  list arcs, l=NULL, curr=NULL;
  int i, j, noarc, otd, vtd;
  multisetPTR p_MS;
  AssignmentPTR gamma;
  status state;
  char *new_var;
  
 init_list(&gListParsedArcs);
 init_list(&YACCParsedVarList);

 
 #if DEBUG_UNFOLD
   printf("Expand transition %s\n\n", trans_el->tag);
 #endif
 
  new_var = FreeVarName();

  for (arc = trans_el->arcs, noarc = 0; arc != NULL; arc = arc->next, noarc++);
                
  parsedArcs = (arcPTR *) Ecalloc( noarc , sizeof(arcPTR));
   
  init_list(&YACCParsedVarList);   

  i = 0; 
  for( arc = trans_el->arcs; arc != NULL; arc = arc->next){
      
   init_list(&l);
   
   if((find_key(gListDomain, (generic_ptr) (arc->place)->tag , CmpDomainName, &l))==OK) 
   {      
     YACCparsedDomain = ((DomainObjPTR) DATA(l));
     Found = FALSE;
     if ( arc->color != NULL ) {
       for ( lisp = net->lisps; lisp != NULL; lisp = lisp->next){       
         if(lisp->type=='f' && (strcmp(arc->color, lisp->tag)==0)) {
	   parsedArcs[i++]= ParseArc(lisp->text);
	   Found = TRUE;
	 }   
       }
       if(Found == FALSE){
        parsedArcs[i++]= ParseArc(arc->color);
	Found = TRUE;
       }
     }
     else if(Found == FALSE && arc->lisp != NULL)
       parsedArcs[i++]= ParseArc(arc->lisp->text);
     else
       parsedArcs[i++]= ParseNoColoredArc(arc, new_var);
   }
   else
     Error(UNDEF_DOM_ERR, "DefTransitions", (arc->place)->tag);
    
  }
   
 
  g = ParseGuard(trans_el, net);      
  create_assignment(&gamma, YACCParsedVarList); 
  
  
  otd = atoi(opt_list[OPT_ORIZ_TRANS_DISPLACEMENT].arg_val);
  vtd = atoi(opt_list[OPT_VERT_TRANS_DISPLACEMENT].arg_val);
  
  l = NULL;
  j = 0;
  init_list(&l);
  for(state = first_assignment(gamma) ; state != ERROR ; j++) {
    #if DEBUG_UNFOLD      
      printf("Assignment %s\n%",print_assignment(gamma));
    #endif
    if(eval_guard_expr(g, gamma) == TRUE){
      unf_trans = unfolding_transition(trans_el, j, gamma, &(unf_net->rpars));      
      unf_trans->center.x += j*otd;
      unf_trans->center.y += j*vtd;
      head_insert(&l, (generic_ptr) unf_trans);
    
      
      i = 0; 
      for( arc = trans_el->arcs; arc != NULL; arc = arc->next)
      {
        #if DEBUG_UNFOLD
          printf("Arc %s \n", PrintArcExpression(parsedArcs[i]));
	#endif        
	
	
	eval_arc(parsedArcs[i], gamma, &p_MS);	
        
		
	arcs = expand_arc(arc, p_MS, parsedArcs[i++]->domain->create_place, unf_net);
// 	destroy_multiset(p_MS);
	curr = NULL;
	while ( (curr = list_iterator(arcs, curr)) != NULL )
	{
	  new_arc = (struct arc_object *) DATA(curr);          
          if(unf_trans->arcs == NULL)
            unf_trans->arcs = new_arc;
          else
            prev_arc->next = new_arc;
          prev_arc = new_arc; 
         
	}
// 	destroy(&arcs, NULL);
      }
            
    } 
    state = next_assignment(gamma);
  }  
  
  return(l);
}