コード例 #1
0
ファイル: jscript.c プロジェクト: VujinovM/anjuta
static void
findJsTags (void)
{
	g_assert (symbols == NULL);
	g_assert (tags == NULL);

	JSNode * global = js_node_new_from_file (getInputFileName());

	JSContext *my_cx;
	GList *calls = NULL;
	my_cx = js_context_new_from_node (global, &calls);
	findTags (my_cx);

	/*Members*/

	get_member_list (my_cx);

	g_list_foreach (tags, (GFunc)makeTagEntry, NULL);

	findGlobal (my_cx);

	g_list_free (symbols);
	symbols = NULL;

	g_list_free (tags);
	tags = NULL;
}
コード例 #2
0
ファイル: objc.c プロジェクト: duchy/ctags-ObjC-5.8.1
/*
 * Grab the C parser and hand it up to findObjCOrObjCppTags
 */
static boolean findObjCTags (const unsigned int passCount) {
  parserDefinition *parser = 0;

  if ( isHeaderFile() ) {
    parser = getCppParser();
  } else {
    parser = getCParser();
  }

  boolean ret = findTags(passCount, parser);
 return ret;
}
コード例 #3
0
ファイル: jscript.c プロジェクト: VujinovM/anjuta
static void
findTags (JSContext *my_cx)
{
	GList *i;
	g_assert (my_cx != NULL);
	if (my_cx->func_name)
	{
		const char *name = my_cx->func_name;
		gint line = my_cx->bline;
		if (name)
		{
			tagEntryInfo *tag = (tagEntryInfo*)malloc (sizeof (tagEntryInfo));
			initTagEntry (tag, name);
			get_file_pos (line, &tag->filePosition, File.fp);
			tag->lineNumber = line;
			tag->isFileScope	= 1;
			tag->kindName = "class";
			tag->kind = 'c';

			symbols = g_list_append (symbols, g_strdup (name));

			if (my_cx->ret_type)
				tag->extensionFields.returnType = my_cx->ret_type->data;
			if (my_cx->func_arg)
			{
				gchar *str = NULL, *t;
				GList *i;
				for (i = my_cx->func_arg; i; i = g_list_next (i))
				{
					g_assert (i->data != NULL);
					if (i == my_cx->func_arg)
						str = g_strdup_printf ("( %s", (gchar*)i->data);
					else
					{
						t = g_strdup_printf ("%s, %s", str, (gchar*)i->data);
						g_free (str);
						str = t;
					}
				}
				t = g_strdup_printf ("%s)", str);
				g_free (str);
				str = t;
				tag->extensionFields.signature = str;
			}
			tags = g_list_append (tags, tag);
		}
	}
	for (i = my_cx->childs; i; i = g_list_next (i))
	{
		findTags (i->data);
	}
}
コード例 #4
0
ファイル: php.c プロジェクト: blackb1rd/ctags
static void findZephirTags (void)
{
	findTags (TRUE);
}
コード例 #5
0
ファイル: php.c プロジェクト: blackb1rd/ctags
static void findPhpTags (void)
{
	findTags (FALSE);
}
コード例 #6
0
int main(int argc, char *argv[])
{
  // change argv to strings
  std::vector<std::string> args;
  for (uint16_t i = 1; i < argc; i++)
  {
    args.push_back(argv[i]);
  }

  // parse arguments
  std::string name = "", tag = "";

  std::vector<struct attribute> attributes;
  bool wantHelp = false, 
       trim = false, 
       keep = false,
       silent = false;
  for (uint16_t i = 0; i < args.size(); i++)
  {
    std::string arg = args.at(i); // current argument

    std::string option = "", parameter = "";

    if (arg[0] == '-')
    {
      const int DASH_N = 2; // number of dashes

      // if long option
      if (arg.substr(0,DASH_N) == "--") 
      {
        size_t eqPos = arg.find("=", DASH_N);
        if (arg == "--help" 
        || arg == "--trim" 
        || arg == "--keep"
        || arg == "--silent") eqPos = 0; // to prevent errors when no '='
        if (eqPos == std::string::npos) {
          if (!silent) std::cerr << "Equal sign missing at argument " << i << std::endl;
          return ARGUMENTS_EXIT;
        }
        option = arg.substr(DASH_N, eqPos-DASH_N);
        parameter = arg.substr(eqPos+1);
      } 
      else // if short option
      {
        option = arg[1];
        if (i < args.size()-1) {
          std::string narg = args.at(i+1); // next argument
          parameter = narg;
        } 
      }
    } else {
      continue; // argument is not an option
    }

    //std::cout << i << ": " <<  option << "=" << parameter << std::endl; //debug

    if (option == "f" || option == "file")
    {
      name = parameter;
    } else
    if (option == "h" || option == "help")
    {
      wantHelp = true;
    } else
    if (option == "t" || option == "tag")
    {
      if (parameter != "") {
        tag = parameter;
      }
    } else
    if (option == "a" || option == "attribute")
    {
      if (parameter != "") {
        size_t eqPos = parameter.find("=");
        if (eqPos == std::string::npos) {
          if (!silent) std::cerr << "Wrong attribute parameters at argument " << i << std::endl;
          return ARGUMENTS_EXIT;
        }
        std::string parameterName   = parameter.substr(0, eqPos);
        std::string parameterValue  = parameter.substr(eqPos+1);
        struct attribute a = { parameterName, parameterValue };
        attributes.push_back(a);
      }
    } else
    if (option == "trim")
    {
      trim = true;
    } else
    if (option == "keep")
    {
      keep = true;
    } else
    if (option == "silent")
    {
      silent = true;
    }
  }

  std::string data = "";
  if (name == "" && !wantHelp) {
    //read from stdin
    std::string line;
    while (std::getline(std::cin, line) ) { 
      data += line + "\n";
    }
  }

  // 'help' in arguments
  if ( (data == "" && name == "") || wantHelp)
  {
    help(argc, argv);
    return ARGUMENTS_EXIT;
  }

  //if file name provided
  if (name != "")
  {
    // open file
    InputFile *file = new InputFile(name);
    if (!file->isGood())
    {
      if (!silent) {
        std::cerr << "Cannot open file " << name;
        std::cerr << std::endl;
      }
      delete file;
      return FILE_EXIT;
    }

    // get data
    data = file->getData();

    // close file
    delete file;
  }

  //left trim data from spaces and tabs
  if (trim) {
    std::istringstream iss(data);
    data = "";
    std::string line;
    while (getline(iss, line) )
    {
      size_t i = 0;
      for (i = 0; i < line.size(); i++)
      {
        if (line[i] != ' ' && line[i] != '\t') break;
      }
      line = line.substr(i)+"\n";
      data += line;
    }
  }

  // get tags
  std::vector<std::string> tags;
  tags = findTags(data, tag, silent);

  // filter by attributes
  std::vector<std::string> elements;
  elements = filterByAttributes(tags, attributes, silent);

  //print results
  for (size_t i = 0; i < elements.size(); i++)
  {
    if (keep)
    {
      std::cout << elements.at(i) << std::endl;
    } else
    {
      size_t beg = 0;
      if (tag == "") {
        tag = "html";
        beg = elements.at(i).find("<"+tag);
      }

      size_t tagOpenEnd  = elements.at(i).find(">", beg);
      size_t tagCloseBeg = elements.at(i).find("</"+tag, tagOpenEnd);

      size_t lastClose = tagCloseBeg;

      while (lastClose != std::string::npos)
      {
        tagCloseBeg = lastClose;
        lastClose = elements.at(i).find("</"+tag, lastClose+1); 
      }

      if (tagOpenEnd  == std::string::npos
      ||  tagCloseBeg == std::string::npos) {
        if (!silent) std::cerr << "Wrong element tag syntax!" << std::endl;
        std::cout << elements.at(i) << std::endl;
        continue;
      }

      std::string e = elements.at(i).substr(tagOpenEnd+1, tagCloseBeg-tagOpenEnd+1-2);
      std::cout << e << std::endl << std::endl;
    }
  }

  return GOOD_EXIT;
}
コード例 #7
0
ファイル: htmlhound.cpp プロジェクト: andresmeidla/html-hound
/*
  Finds all the tags which start with the supllied tag from the supplied html.
*/
bool getElements(const std::u32string& html, const std::u32string& tagStartWithAttrs, std::vector<Position>& positions)
{
  size_t tagEndLen;

  if(tagStartWithAttrs.length() == 0 || tagStartWithAttrs[0] != U'<') {
    fprintf(stderr, "invalid tagStartWithAttrs supplied: must start with <\n");
    return false;
  }
  TagItems tagItems(tagStartWithAttrs);
  tagEndLen = tagItems.tagEnd.length();

  std::map<std::u32string, std::vector<Position> > tagLocations;
  tagLocations[tagStartWithAttrs] = std::vector<Position>();
  tagLocations[tagItems.tagStart] = std::vector<Position>();
  tagLocations[tagItems.tagEnd] = std::vector<Position>();
  // search all occurrences of tagStartWithAttrs, tagStart and tagEnd
  findTags(html, tagLocations);
  std::vector<Position>::iterator endItr = tagLocations[tagItems.tagEnd].begin();
  std::vector<Position>::iterator startItr = tagLocations[tagItems.tagStart].begin();
  if(startItr == tagLocations[tagItems.tagStart].end())
    return true;

  std::stack<Position> stack;
  std::map<int, int> startTagMap;
  for(std::vector<Position>::iterator itr = tagLocations[tagStartWithAttrs].begin(); itr != tagLocations[tagStartWithAttrs].end(); ++itr) {
    startTagMap[itr->start] = itr->start;
  }
  stack.push(*startItr);
  ++startItr;

  // match start tags with end tags
  while(stack.size() > 0 && endItr != tagLocations[tagItems.tagEnd].end()) {
    // check if the end tag closes the current tag in the stack
    if(endItr->start > stack.top().start &&
      (startItr == tagLocations[tagItems.tagStart].end() || endItr->start < startItr->start)) {
      Position pos = stack.top();
      pos.len = endItr->start + tagEndLen - pos.start;
      ++endItr;
      stack.pop();
      if(startTagMap.find(pos.start) != startTagMap.end()) {
        // matches tag with attributes
        positions.push_back(pos);
      }

      // only add new start tag to the stack if there are none in the stack.
      // we want to close the tags in the stack next
      if(stack.size() == 0 && startItr != tagLocations[tagItems.tagStart].end()) {
        stack.push(*startItr);
        ++startItr;
      }
    } else {
      // the end tag did not match the start tag, must search for an embedded element.
      // add a start tag
      if(startItr != tagLocations[tagItems.tagStart].end()) {
        if(startItr != tagLocations[tagItems.tagStart].end()) {
          stack.push(*startItr);
          ++startItr;
        }
      }
    }
  }

  return true;
}