Array ::= "*(" TypeDecl ")*"
173323
final public JSRepeated Array(Map refs) throws ParseException {
                               JSType item;
    jj_consume_token(3);
    item = TypeDecl(refs);
    jj_consume_token(4);
    JSRepeated ans = new JSRepeated();
    ans.setItemType(item);
    {if (true) return ans;}
    throw new Error("Missing return statement in function");
  }
806618
function isArray(a) {
	return (a && (($.browser.safari && typeof a == 'object' && a.length) ||
		(a.constructor && a.constructor.toString().match(/\Array\(\)/))));
}
666110
function getTypes()
    {
        $t = array();
        foreach ($this->getElements('xrd:Type') as $elem) {
            $c = $this->parser->content($elem);
            if ($c) {
                $t[] = $c;
            }
        }
        return $t;
    }
275806
static function parse(array $tokens, &$i) {
    if (T_NS_SEPARATOR !== $tokens[$i][0]) {
      return FALSE;
    }
    ++$i;
    $qcnString = '';
    while (TRUE) {
      if (T_STRING !== $tokens[$i][0]) {
        return FALSE;
      }
      $qcnString .= $tokens[$i][1];
      ++$i;
      if (T_NS_SEPARATOR !== $tokens[$i][0]) {
        break;
      }
      $qcnString .= '\\';
      ++$i;
    }
    return Fqcn::createFromValidFqcnString($qcnString);
  }
954648
final public JSType TypeDecl(Map refs) throws ParseException {
                              JSType ans; String name = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IDENTIFIER:
      name = Name();
      break;
    default:
      jj_la1[1] = jj_gen;
      ;
    }
    ans = TypeDef(refs);
    if (name != null)
      ans.setFeatureName(name);
    {if (true) return ans;}
    throw new Error("Missing return statement in function");
  }
430371
public static function charAsciiAlphaArray()
    {
        static $result = array();

        if (!$result) {
            $result = \array_merge(
                self::charAsciiAlphaLowerArray(),
                self::charAsciiAlphaUpperArray()
            );
        }

        return $result;
    }
247677
protected function _parseArgs()
    {
        $cpt = 0;
        $value = $name = '';
        $args = [];
        $body = '';
        while ($token = $this->_stream->current(true)) {
            $body .= $token[1];
            switch ($token[0]) {
                case '(':
                    if ($cpt) {
                        $value .= $token[1];
                    }
                    $cpt++;
                    break;
                case '=':
                    $name = $value;
                    $value = '';
                    break;
                case ')':
                    $cpt--;
                    if ($cpt) {
                        $value .= $token[1];
                        break;
                    }
                    /* Same behavior as comma */
                case ',':
                    $value = trim($value);
                    if ($value !== '') {
                        $name ? $args[trim($name)] = $value : $args[] = $value;
                    }
                    $name = $value = '';
                    break;
                default:
                    $value .= $token[1];
                    break;
            }
            if ($token[1] === ')' && $cpt === 0) {
                break;
            }
            $this->_stream->next();
        }
        return compact('args', 'body');
    }
1092116
function find(array, exp) {
  return (isArray(array) && isDefined(exp))
    //return the member and not an array like `first`
    ? findInArray(array, $parse(exp), false)
    : array;
}
663125
protected function compileOrdering(array $ordering): string
    {
        $result = [];
        foreach ($ordering as $order) {
            $direction = strtoupper($order[1]);

            if (!in_array($direction, ['ASC', 'DESC'])) {
                throw new CompilerException("Invalid sorting direction, only ASC and DESC are allowed");
            }

            $result[] = $this->quote($order[0]) . ' ' . $direction;
        }

        return implode(', ', $result);
    }
1326953
function typedValues(svalue) {
    var commaSplit = /("[^"]*")|('[^']*')|([^,]+)/g
    var values = []
    svalue
        .match(commaSplit)
        .forEach(function(value) {
            values.push(typedValue(value))
        })
    return values;
}
454031
function inArray(src, find, findByKey) {
    if (src.indexOf && !findByKey) {
        return src.indexOf(find);
    } else {
        var i = 0;
        while (i < src.length) {
            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
                return i;
            }
            i++;
        }
        return -1;
    }
}
147649
public static function charAsciiAlphaUpperArray()
    {
        static $result = array();

        if (!$result) {
            for ($i = 65; $i < 91; ++$i) {
                $result[] = \chr($i);
            }
        }

        return $result;
    }
1088069
function ajouter($elem){
		echo "ajouter";
		
		if(is_array($elem)){
			foreach ($elem as $e){
				$array_messages[] =$e;
			}
		}
		else
		{
			$array_messages[]   = $elem;
		}
		
	}
1050751
function parseArray(array) {
  const templates = array.map(parse);
  const templateParameters = templates.reduce(
    (parameters, template) => parameters.concat(template.parameters),
    []
  );
  const templateFn = context => templates.map(template => template(context));

  return Template(templateFn, templateParameters);
}
427324
function class_declaration() {
    $line = '';
    $line .= "interface {$this->component_data['plain_class_name']}";
    if ($this->component_data['parent_interface_names']) {
      $line .= ' extends ';
      $line .= implode(', ', $this->component_data['parent_interface_names']);
    }
    $line .= ' {';

    return [
      $line,
    ];
  }
913586
function serializeTypeDef($type)
    {
        //print "in sTD() for type $type<br>";
        if ($typeDef = $this->getTypeDef($type)) {
            $str .= '<' . $type;
            if (is_array($typeDef['attrs'])) {
                foreach ($typeDef['attrs'] as $attName => $data) {
                    $str .= " $attName=\"{type = " . $data['type'] . "}\"";
                }
            }
            $str .= " xmlns=\"" . $this->schema['targetNamespace'] . "\"";
            if (count($typeDef['elements']) > 0) {
                $str .= ">";
                foreach ($typeDef['elements'] as $element => $eData) {
                    $str .= $this->serializeTypeDef($element);
                }
                $str .= "</$type>";
            } elseif ($typeDef['typeClass'] == 'element') {
                $str .= "></$type>";
            } else {
                $str .= "/>";
            }

            return $str;
        }

        return FALSE;
    }
386873
private function ArrayEntry()
	{
		$peek = $this->lexer->glimpse();

		if ( DocLexer::T_EQUALS === $peek['type'] || DocLexer::T_COLON === $peek['type'] )
		{
			if ( $this->lexer->isNextToken( DocLexer::T_IDENTIFIER ) )
				$key = $this->Constant();
			else
			{
				$this->matchAny( [DocLexer::T_INTEGER, DocLexer::T_STRING] );
				$key = $this->lexer->token['value'];
			}

			$this->matchAny( [DocLexer::T_EQUALS, DocLexer::T_COLON] );

			return [$key, $this->PlainValue()];
		}

		return [null, $this->Value()];
	}