コード例 #1
0
  bool MOL2Format::ReadMolecule(OBBase* pOb, OBConversion* pConv)
  {

    OBMol* pmol = pOb->CastAndClear<OBMol>();
    if(pmol==NULL)
      return false;

    //Define some references so we can use the old parameter names
    istream &ifs = *pConv->GetInStream();
    OBMol &mol = *pmol;

    //Old code follows...
    bool foundAtomLine = false;
    char buffer[BUFF_SIZE];
    char *comment = NULL;
    string str,str1;
    vector<string> vstr;
    int len;

    mol.BeginModify();

    for (;;)
      {
        if (!ifs.getline(buffer,BUFF_SIZE))
          return(false);
        if (EQn(buffer,"@<TRIPOS>MOLECULE",17))
          break;
      }

    // OK, just read MOLECULE line
    int lcount;
    int natoms,nbonds;
    bool hasPartialCharges = true;
    for (lcount=0;;lcount++)
      {
        if (!ifs.getline(buffer,BUFF_SIZE))
          return(false);
        if (EQn(buffer,"@<TRIPOS>ATOM",13))
          {
            foundAtomLine = true;
            break;
          }

        if (lcount == 0)
          {
            tokenize(vstr,buffer);
            if (!vstr.empty())
              mol.SetTitle(buffer);
          }
        else if (lcount == 1)
          sscanf(buffer,"%d%d",&natoms,&nbonds);
        else if (lcount == 3) // charge descriptions
          {
            // Annotate origin of partial charges
            OBPairData *dp = new OBPairData;
            dp->SetAttribute("PartialCharges");
            dp->SetValue(buffer);
            dp->SetOrigin(fileformatInput);
            mol.SetData(dp);

            if (strncasecmp(buffer, "NO_CHARGES", 10) == 0)
              hasPartialCharges = false;
          }
        else if (lcount == 4) //energy (?)
          {
            tokenize(vstr,buffer);
            if (!vstr.empty() && vstr.size() == 3)
              if (vstr[0] == "Energy")
                mol.SetEnergy(atof(vstr[2].c_str()));
          }
        else if (lcount == 5) //comment
          {
            if ( buffer[0] )
              {
                len = (int) strlen(buffer)+1;
                //! @todo allow better multi-line comments
                // which don't allow ill-formed data to consume memory
                // Thanks to Andrew Dalke for the pointer
                if (comment != NULL)
                  delete [] comment;
                comment = new char [len];
                memcpy(comment,buffer,len);
              }
          }
      }

    if (!foundAtomLine)
      {
        mol.EndModify();
        mol.Clear();
        obErrorLog.ThrowError(__FUNCTION__, "Unable to read Mol2 format file. No atoms found.", obWarning);
        return(false);
      }

    mol.ReserveAtoms(natoms);

    int i;
    vector3 v;
    OBAtom atom;
    double x,y,z,pcharge;
    char temp_type[BUFF_SIZE], resname[BUFF_SIZE], atmid[BUFF_SIZE];
    int elemno, resnum = -1;

    ttab.SetFromType("SYB");
    for (i = 0;i < natoms;i++)
      {
        if (!ifs.getline(buffer,BUFF_SIZE))
          return(false);
        sscanf(buffer," %*s %1024s %lf %lf %lf %1024s %d %1024s %lf",
               atmid, &x,&y,&z, temp_type, &resnum, resname, &pcharge);

        atom.SetVector(x, y, z);

        // Handle "CL" and "BR" and other mis-typed atoms
        str = temp_type;
        if (strncmp(temp_type, "CL", 2) == 0) {
          str = "Cl";
        } else  if (strncmp(temp_type,"BR",2) == 0) {
          str = "Br";
        } else if (strncmp(temp_type,"S.o2", 4) == 02) {
          str = "S.O2";
        } else if (strncmp(temp_type,"S.o", 3) == 0) {
          str = "S.O";
        } else if (strncmp(temp_type,"SI", 2) == 0) {
          str = "Si";
        // The following cases are entries which are not in openbabel/data/types.txt
        // and should probably be added there
        } else if (strncmp(temp_type,"S.1", 3) == 0) {
          str = "S.2"; // no idea what the best type might be here
        } else if (strncmp(temp_type,"P.", 2) == 0) {
          str = "P.3";
        } else if (strncasecmp(temp_type,"Ti.", 3) == 0) { // e.g. Ti.th
          str = "Ti";
        } else if (strncasecmp(temp_type,"Ru.", 3) == 0) { // e.g. Ru.oh
          str = "Ru";
        }

        ttab.SetToType("ATN");
        ttab.Translate(str1,str);
        elemno = atoi(str1.c_str());
        ttab.SetToType("IDX");

        // We might have missed some SI or FE type things above, so here's
        // another check
        if( !elemno && isupper(temp_type[1]) )
          {
            temp_type[1] = (char)tolower(temp_type[1]);
            str = temp_type;
            ttab.Translate(str1,str);
            elemno = atoi(str1.c_str());
          }
        // One last check if there isn't a period in the type,
        // it's a malformed atom type, but it may be the element symbol
        // GaussView does this (PR#1739905)
        if ( !elemno ) {
          obErrorLog.ThrowError(__FUNCTION__, "This Mol2 file is non-standard. Cannot interpret atom types correctly, instead attempting to interpret as elements instead.", obWarning);

          string::size_type dotPos = str.find('.');
          if (dotPos == string::npos) {
            elemno = etab.GetAtomicNum(str.c_str());
          }
        }

        atom.SetAtomicNum(elemno);
        ttab.SetToType("INT");
        ttab.Translate(str1,str);
        atom.SetType(str1);
        atom.SetPartialCharge(pcharge);
        if (!mol.AddAtom(atom))
          return(false);
        if (!IsNearZero(pcharge))
          hasPartialCharges = true;

        // Add residue information if it exists
        if (resnum != -1 && resnum != 0 &&
            strlen(resname) != 0 && strncmp(resname,"<1>", 3) != 0)
          {
            OBResidue *res  = (mol.NumResidues() > 0) ?
              mol.GetResidue(mol.NumResidues()-1) : NULL;
            if (res == NULL || res->GetName() != resname ||
                static_cast<int>(res->GetNum()) != resnum)
              {
                vector<OBResidue*>::iterator ri;
                for (res = mol.BeginResidue(ri) ; res ; res = mol.NextResidue(ri))
                  if (res->GetName() == resname &&
                      static_cast<int>(res->GetNum()) == resnum)
                    break;

                if (res == NULL)
                  {
                    res = mol.NewResidue();
                    res->SetName(resname);
                    res->SetNum(resnum);
                  }
              }
            OBAtom *atomPtr = mol.GetAtom(mol.NumAtoms());
            res->AddAtom(atomPtr);
            res->SetAtomID(atomPtr, atmid);
          } // end adding residue info
      }

    for (;;)
      {
        if (!ifs.getline(buffer,BUFF_SIZE))
          return(false);
        str = buffer;
        if (!strncmp(buffer,"@<TRIPOS>BOND",13))
          break;
      }

    int start,end,order;
    for (i = 0; i < nbonds; i++)
      {
        if (!ifs.getline(buffer,BUFF_SIZE))
          return(false);

        sscanf(buffer,"%*d %d %d %1024s",&start,&end,temp_type);
        str = temp_type;
        order = 1;
        if (str == "ar" || str == "AR" || str == "Ar")
          order = 5;
        else if (str == "AM" || str == "am" || str == "Am")
          order = 1;
        else
          order = atoi(str.c_str());

        mol.AddBond(start,end,order);
      }

    // Suggestion by Liu Zhiguo 2008-01-26
    // Mol2 files define atom types -- there is no need to re-perceive
    mol.SetAtomTypesPerceived();
    mol.EndModify();

    //must add generic data after end modify - otherwise it will be blown away
    if (comment)
      {
        OBCommentData *cd = new OBCommentData;
        cd->SetData(comment);
        cd->SetOrigin(fileformatInput);
        mol.SetData(cd);
        delete [] comment;
        comment = NULL;
      }
    if (hasPartialCharges)
      mol.SetPartialChargesPerceived();

    /* Disabled due to PR#3048758 -- seekg is very slow with gzipped mol2
    // continue untill EOF or untill next molecule record
    streampos pos;
    for(;;)
      {
        pos = ifs.tellg();
        if (!ifs.getline(buffer,BUFF_SIZE))
          break;
        if (EQn(buffer,"@<TRIPOS>MOLECULE",17))
          break;
      }

    ifs.seekg(pos); // go back to the end of the molecule
    */
    return(true);
  }
コード例 #2
0
ファイル: cmdline.cpp プロジェクト: KenKappler/serpent
int main(int argv, char** argc) {
    if (argv == 1) {
        std::cerr << "Must provide a command and arguments! Try parse, rewrite, compile, assemble\n";
        return 0;
    }
    if (argv == 2 && std::string(argc[1]) == "--help" || std::string(argc[1]) == "-h" ) {
        std::cout << argc[1] << "\n";
        
        std::cout << "serpent command input\n";
        std::cout << "where input -s for from stdin, a file, or interpreted as serpent code if does not exist as file.";
        std::cout << "where command: \n";
        std::cout << " parse:          Just parses and returns s-expression code.\n";
        std::cout << " rewrite:        Parse, use rewrite rules print s-expressions of result.\n";
        std::cout << " compile:        Return resulting compiled EVM code in hex.\n";
        std::cout << " assemble:       Return result from step before compilation.\n";
        return 0;
    }
        
    std::string flag = "";
    std::string command = argc[1];
    std::string input;
    std::string secondInput;
    if (std::string(argc[1]) == "-s") {
        flag = command.substr(1);
        command = argc[2];
        input = "";
        std::string line;
        while (std::getline(std::cin, line)) {
            input += line + "\n";
        }
        secondInput = argv == 3 ? "" : argc[3];
    }
    else {
        if (argv == 2) {
            std::cerr << "Not enough arguments for serpent cmdline\n";
            throw(0);
        }
        input = argc[2];
        secondInput = argv == 3 ? "" : argc[3];
    }
    bool haveSec = secondInput.length() > 0;
    if (command == "parse" || command == "parse_serpent") {
        std::cout << printAST(parseSerpent(input), haveSec) << "\n";
    }
    else if (command == "rewrite") {
        std::cout << printAST(rewrite(parseLLL(input, true)), haveSec) << "\n";
    }
    else if (command == "compile_to_lll") {
        std::cout << printAST(compileToLLL(input), haveSec) << "\n";
    }
    else if (command == "rewrite_chunk") {
        std::cout << printAST(rewriteChunk(parseLLL(input, true)), haveSec) << "\n";
    }
    else if (command == "compile_chunk_to_lll") {
        std::cout << printAST(compileChunkToLLL(input), haveSec) << "\n";
    }
    else if (command == "build_fragtree") {
        std::cout << printAST(buildFragmentTree(parseLLL(input, true))) << "\n";
    }
    else if (command == "compile_lll") {
        std::cout << binToHex(compileLLL(parseLLL(input, true))) << "\n";
    }
    else if (command == "dereference") {
        std::cout << printAST(dereference(parseLLL(input, true)), haveSec) <<"\n";
    }
    else if (command == "pretty_assemble") {
        std::cout << printTokens(prettyAssemble(parseLLL(input, true))) <<"\n";
    }
    else if (command == "pretty_compile_lll") {
        std::cout << printTokens(prettyCompileLLL(parseLLL(input, true))) << "\n";
    }
    else if (command == "pretty_compile") {
        std::cout << printTokens(prettyCompile(input)) << "\n";
    }
    else if (command == "pretty_compile_chunk") {
        std::cout << printTokens(prettyCompileChunk(input)) << "\n";
    }
    else if (command == "assemble") {
        std::cout << assemble(parseLLL(input, true)) << "\n";
    }
    else if (command == "serialize") {
        std::cout << binToHex(serialize(tokenize(input, Metadata(), false))) << "\n";
    }
    else if (command == "flatten") {
        std::cout << printTokens(flatten(parseLLL(input, true))) << "\n";
    }
    else if (command == "deserialize") {
        std::cout << printTokens(deserialize(hexToBin(input))) << "\n";
    }
    else if (command == "compile") {
        std::cout << binToHex(compile(input)) << "\n";
    }
    else if (command == "compile_chunk") {
        std::cout << binToHex(compileChunk(input)) << "\n";
    }
    else if (command == "encode_datalist") {
        std::vector<Node> tokens = tokenize(input);
        std::vector<std::string> o;
        for (int i = 0; i < (int)tokens.size(); i++) {
            o.push_back(tokens[i].val);
        }
        std::cout << binToHex(encodeDatalist(o)) << "\n";
    }
    else if (command == "decode_datalist") {
        std::vector<std::string> o = decodeDatalist(hexToBin(input));
        std::vector<Node> tokens;
        for (int i = 0; i < (int)o.size(); i++)
            tokens.push_back(token(o[i]));
        std::cout << printTokens(tokens) << "\n";
    }
    else if (command == "tokenize") {
        std::cout << printTokens(tokenize(input));
    }
    else if (command == "biject") {
        if (argv == 3)
             std::cerr << "Not enough arguments for biject\n";
        int pos = decimalToUnsigned(secondInput);
        std::vector<Node> n = prettyCompile(input);
        if (pos >= (int)n.size())
             std::cerr << "Code position too high\n";
        Metadata m = n[pos].metadata;
        std::cout << "Opcode: " << n[pos].val << ", file: " << m.file << 
             ", line: " << m.ln << ", char: " << m.ch << "\n";
    }
}
コード例 #3
0
ファイル: pwscfformat.cpp プロジェクト: Reinis/openbabel
  bool PWscfFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv)
  {
    OBMol* pmol = pOb->CastAndClear<OBMol>();
    if(pmol==NULL)
      return false;

    //Define some references so we can use the old parameter names
    istream &ifs = *pConv->GetInStream();

    char buffer[BUFF_SIZE], tag[BUFF_SIZE];
    double x,y,z;
    double alat = 1.0;
    vector<string> vs;
    matrix3x3 ortho;
    int atomicNum;
    OBUnitCell *cell = new OBUnitCell();
    bool hasEnthalpy=false;
    double enthalpy, pv;

    pmol->BeginModify();

    while (ifs.getline(buffer,BUFF_SIZE)) {

      // Older version of pwscf may use this for alat
      if (strstr(buffer, "lattice parameter (a_0)")) {
        tokenize(vs, buffer);
        alat = atof(vs.at(4).c_str());
      }

      // Newer versions will use this for alat instead
      if (strstr(buffer, "lattice parameter (alat)")) {
        tokenize(vs, buffer);
        alat = atof(vs.at(4).c_str());
      }

      // Unit cell info
      // Newer versions will also say "CELL_PARAMETERS" to complain that no
      // units were specified
      if (strstr(buffer, "CELL_PARAMETERS") &&
          !strstr(buffer, "no units specified in CELL_PARAMETERS card")) {
        // Discover units
        double conv = 1.0;
        tokenize(vs, buffer);

        if (strstr(vs[1].c_str(), "alat")) {
          conv = alat * BOHR_TO_ANGSTROM;
        }
        else if (strstr(vs[1].c_str(), "bohr")) {
          conv = BOHR_TO_ANGSTROM;
        }
        // Add others if needed

        double v11, v12, v13,
          v21, v22, v23,
          v31, v32, v33;

        ifs.getline(buffer,BUFF_SIZE); // v1
        tokenize(vs, buffer);
        v11 = atof(vs.at(0).c_str()) * conv;
        v12 = atof(vs.at(1).c_str()) * conv;
        v13 = atof(vs.at(2).c_str()) * conv;

        ifs.getline(buffer,BUFF_SIZE); // v2
        tokenize(vs, buffer);
        v21 = atof(vs.at(0).c_str()) * conv;
        v22 = atof(vs.at(1).c_str()) * conv;
        v23 = atof(vs.at(2).c_str()) * conv;

        ifs.getline(buffer,BUFF_SIZE); // v3
        tokenize(vs, buffer);
        v31 = atof(vs.at(0).c_str()) * conv;
        v32 = atof(vs.at(1).c_str()) * conv;
        v33 = atof(vs.at(2).c_str()) * conv;

        // Build unit cell
        cell->SetData(vector3(v11,v12,v13),
                      vector3(v21,v22,v23),
                      vector3(v31,v32,v33));
      }

      // Unit cell info (for non-variable cell calcs)
      if (strstr(buffer, "crystal axes: (cart. coord. in units of a_0)") ||
          strstr(buffer, "crystal axes: (cart. coord. in units of alat)")) {
        double conv = alat * BOHR_TO_ANGSTROM;
        double v11, v12, v13,
          v21, v22, v23,
          v31, v32, v33;

        ifs.getline(buffer,BUFF_SIZE); // v1
        tokenize(vs, buffer);
        v11 = atof(vs.at(3).c_str()) * conv;
        v12 = atof(vs.at(4).c_str()) * conv;
        v13 = atof(vs.at(5).c_str()) * conv;

        ifs.getline(buffer,BUFF_SIZE); // v2
        tokenize(vs, buffer);
        v21 = atof(vs.at(3).c_str()) * conv;
        v22 = atof(vs.at(4).c_str()) * conv;
        v23 = atof(vs.at(5).c_str()) * conv;

        ifs.getline(buffer,BUFF_SIZE); // v3
        tokenize(vs, buffer);
        v31 = atof(vs.at(3).c_str()) * conv;
        v32 = atof(vs.at(4).c_str()) * conv;
        v33 = atof(vs.at(5).c_str()) * conv;

        // Build unit cell
        cell->SetData(vector3(v11,v12,v13),
                      vector3(v21,v22,v23),
                      vector3(v31,v32,v33));
      }

      // Atoms info
      if (strstr(buffer, "ATOMIC_POSITIONS")) {
        // Clear old atoms from pmol
        vector<OBAtom*> toDelete;
        FOR_ATOMS_OF_MOL(a, *pmol)
          toDelete.push_back(&*a);
        for (size_t i = 0; i < toDelete.size(); i++)
          pmol->DeleteAtom(toDelete.at(i));


        // Discover units
        matrix3x3 conv (1);
        tokenize(vs, buffer);

        if (strstr(vs[1].c_str(), "alat")) {
          conv *= (alat * BOHR_TO_ANGSTROM);
        }
        else if (strstr(vs[1].c_str(), "crystal")) {
          // Set to the zero matrix and test below.
          conv = matrix3x3 (0.0);
        }
        // Add others if needed

        // Load new atoms from molecule
        ifs.getline(buffer,BUFF_SIZE); // First entry
        tokenize(vs, buffer);
        int size = vs.size();
        while (size == 4) {
          atomicNum = OBElements::GetAtomicNum(vs[0].c_str());
          x = atof((char*)vs[1].c_str());
          y = atof((char*)vs[2].c_str());
          z = atof((char*)vs[3].c_str());
          // Add atom
          OBAtom *atom = pmol->NewAtom();
          atom->SetAtomicNum(atomicNum);
          vector3 coords (x,y,z);
          if (conv.determinant() == 0.0) { // Fractional coords
            atom->SetVector(cell->FractionalToCartesian(coords));
          }
          else {
            atom->SetVector(conv * coords);
          }

          // Reset vars
          ifs.getline(buffer,BUFF_SIZE); // First entry
          tokenize(vs, buffer);
          size = vs.size();
        }
      }

      // Free energy
      if (strstr(buffer, "Final energy =")) {
        tokenize(vs, buffer);
        pmol->SetEnergy(atof(vs[3].c_str()) * RYDBERG_TO_KCAL_PER_MOL);
      }

      // H - PV = U energy
      if (strstr(buffer, "!    total energy              =")) {
        tokenize(vs, buffer);
        pmol->SetEnergy(atof(vs[4].c_str()) * RYDBERG_TO_KCAL_PER_MOL);
      }

      // Enthalphy
      if (strstr(buffer, "Final enthalpy =")) {
        tokenize(vs, buffer);

        hasEnthalpy = true;
        enthalpy = atof(vs.at(3).c_str()) * RYDBERG_TO_KCAL_PER_MOL;
        pv = enthalpy - pmol->GetEnergy();
      }
    }

    // set final unit cell
    pmol->SetData(cell);

    // Set enthalpy
    if (hasEnthalpy) {
      OBPairData *enthalpyPD = new OBPairData();
      OBPairData *enthalpyPD_pv = new OBPairData();
      OBPairData *enthalpyPD_eV = new OBPairData();
      OBPairData *enthalpyPD_pv_eV = new OBPairData();
      enthalpyPD->SetAttribute("Enthalpy (kcal/mol)");
      enthalpyPD_pv->SetAttribute("Enthalpy PV term (kcal/mol)");
      enthalpyPD_eV->SetAttribute("Enthalpy (eV)");
      enthalpyPD_pv_eV->SetAttribute("Enthalpy PV term (eV)");
      double en_kcal_per_mole = enthalpy;
      double pv_kcal_per_mole = pv;
      double en_eV = enthalpy / EV_TO_KCAL_PER_MOL;
      double pv_eV = pv / EV_TO_KCAL_PER_MOL;
      snprintf(tag, BUFF_SIZE, "%f", en_kcal_per_mole);
      enthalpyPD->SetValue(tag);
      snprintf(tag, BUFF_SIZE, "%f", pv_kcal_per_mole);
      enthalpyPD_pv->SetValue(tag);
      snprintf(tag, BUFF_SIZE, "%f", en_eV);
      enthalpyPD_eV->SetValue(tag);
      snprintf(tag, BUFF_SIZE, "%f", pv_eV);
      enthalpyPD_pv_eV->SetValue(tag);
      pmol->SetData(enthalpyPD);
      pmol->SetData(enthalpyPD_pv);
      pmol->SetData(enthalpyPD_eV);
      pmol->SetData(enthalpyPD_pv_eV);
    }

    pmol->EndModify();

    return true;
  }
コード例 #4
0
gint nwchem_input_import(gpointer import)
{
gint *symbols, num_symbols, num_tokens, value;
gchar *line, **buff;
gpointer scan, config;
GString *unparsed;
struct model_pak *model=NULL; // CURRENT - will break if more than one in a file
struct nwchem_pak *nwchem;

scan = scan_new(import_fullpath(import));
if (!scan)
  return(1);

/* populate symbol table */
nwchem_scan_symbols_init(scan);

config = config_new(NWCHEM, NULL);
nwchem = config_data(config);

unparsed = g_string_new(NULL);

while (!scan_complete(scan))
  {
  symbols = scan_get_symbols(scan, &num_symbols);

  if (num_symbols)
    {
/* process first recognized symbol */
    value = symbols[0];
    switch (value)
      {
      case NWCHEM_START:
/* TODO - could this serve as title? */
        nwchem->start = parse_strip(scan_cur_line(scan));
        break;

      case NWCHEM_BASIS:
// TODO - don't want to use this for predefined basis sets
        read_nwchem_basis_library(scan, config);
        break;

      case NWCHEM_CHARGE:
        line = scan_cur_line(scan);
        buff = tokenize(line, &num_tokens);
        if (num_tokens > 1)
          nwchem->charge = g_strdup(buff[1]);
        g_strfreev(buff);
        break;

      case NWCHEM_GEOMETRY:
        if (!model)
          {
          model = model_new();
          import_object_add(IMPORT_MODEL, model, import);
          }
        read_nwchem_geometry(scan, model);
        break;

      case NWCHEM_SYSTEM:
        if (!model)
          {
          model = model_new();
          import_object_add(IMPORT_MODEL, model, import);
          }
        read_nwchem_system(scan, model);
        break;

      case NWCHEM_TASK:
        read_nwchem_task(scan, config, symbols, num_symbols);
        break;

      default:
/* add lines that have recognized symbols (but no special trigger) to unparsed */
/* this'll happen for symbols that occur in multiple locations (eg dft) */
        line = scan_cur_line(scan);
        if (line)
          g_string_append(unparsed, line);
      }

    g_free(symbols);
    }
  else
    {
/* add non-NULL lines to unparsed list */
    line = scan_cur_line(scan);
    if (line)
      g_string_append(unparsed, line);
    }
  }

config_unparsed_set(g_string_free(unparsed, FALSE), config);
import_object_add(IMPORT_CONFIG, config, import);

scan_free(scan);

import_init(import);

return(0);
}
コード例 #5
0
Event *
create_riemann_event (const char *grid, const char *cluster, const char *host, const char *ip,
                      const char *metric, const char *value, const char *type, const char *units,
                      const char *state, unsigned int localtime, const char *tags_str,
                      const char *location, unsigned int ttl)
{
/*
  debug_msg("[riemann] grid=%s, cluster=%s, host=%s, ip=%s, metric=%s, value=%s %s, type=%s, state=%s, "
            "localtime=%u, tags=%s, location=%s, ttl=%u\n", grid, cluster, host, ip, metric, value,
            units, type, state, localtime, tags_str, location, ttl);
*/
  Event *event = malloc (sizeof (Event));
  event__init (event);

  event->host = strdup (host);
  event->service = strdup (metric);

  if (value) {
    if (!strcmp (type, "int")) {
      event->has_metric_sint64 = 1;
      event->metric_sint64 = strtol (value, (char **) NULL, 10);
    }
    else if (!strcmp (type, "float")) {
      event->has_metric_d = 1;
      event->metric_d = (double) strtod (value, (char **) NULL);
    }
    else {
      event->state = strdup (value);
    }
  }

  event->description = strdup (units);

  if (state)
    event->state = strdup (state);

  if (localtime)
    event->time = localtime;

  char *tags[64] = { NULL };

  event->n_tags = tokenize (tags_str, ",", tags);
  event->tags = malloc (sizeof (char *) * (event->n_tags));
  int j;
  for (j = 0; j< event->n_tags; j++) {
     event->tags[j] = strdup (tags[j]);
     free(tags[j]);
  }

  char attr_str[512];
  sprintf(attr_str, "grid=%s,cluster=%s,ip=%s,location=%s%s%s", grid, cluster, ip, location,
        gmetad_config.riemann_attributes ? "," : "",
        gmetad_config.riemann_attributes ? gmetad_config.riemann_attributes : "");

  char *kv[64] = { NULL };
  event->n_attributes = tokenize (attr_str, ",", kv);

  Attribute **attrs;
  attrs = malloc (sizeof (Attribute *) * (event->n_attributes));

  int i;
  for (i = 0; i < event->n_attributes; i++) {

    char *pair[2] = { NULL };
    tokenize (kv[i], "=", pair);
    free(kv[i]);

    attrs[i] = malloc (sizeof (Attribute));
    attribute__init (attrs[i]);
    attrs[i]->key = strdup(pair[0]);
    attrs[i]->value = strdup(pair[1]);
    free(pair[0]);
    free(pair[1]);
  }
  event->attributes = attrs;

  event->has_ttl = 1;
  event->ttl = ttl;
/*
  debug_msg("[riemann] %zu host=%s, service=%s, state=%s, metric_f=%f, metric_d=%lf, metric_sint64=%" PRId64
            ", description=%s, ttl=%f, tags(%zu), attributes(%zu)", event->time, event->host, event->service,
            event->state, event->metric_f, event->metric_d, event->metric_sint64, event->description,
            event->ttl, event->n_tags, event->n_attributes);
*/
  return event;
}
コード例 #6
0
ファイル: tokenline.c プロジェクト: biot/tokenline
static void complete(t_tokenline *tl)
{
	t_token *tokens, *partial;
	unsigned int i;
	int words[TL_MAX_WORDS], num_words, arg_needed, multiple;
	int reprompt, t;
	char *word;

	reprompt = FALSE;
	if (!tl->pos) {
		/* Tab on an empty line: show all commmands. */
		tl->print(tl->user, NL);
		tokens = tl->token_levels[tl->token_level];
		for (i = 0; tokens[i].token; i++) {
			print_token_and_help(tl, &tokens[i]);
			tl->print(tl->user, NL);
		}
		reprompt = TRUE;
	} else if (tl->buf[tl->pos - 1] != ' ') {
		/* Try to complete the current word. */
		if (!split_line(tl, words, &num_words, TRUE) || !num_words)
			return;
		if (tokenize(tl, words, num_words - 1, &tokens, NULL)) {
			if (tokens) {
				word = tl->buf + words[num_words - 1];
				partial = NULL;
				multiple = FALSE;
				for (t = 0; tokens[t].token; t++) {
					if (tokens[t].token >= T_ARG_UINT)
						continue;
					if (!strncmp(word, tl->token_dict[tokens[t].token].tokenstr, strlen(word))) {
						if (partial) {
							/* Not the first match, print previous one. */
							multiple = TRUE;
							tl->print(tl->user, NL);
							print_token_and_help(tl, partial);
						}
						partial = &tokens[t];
					}
				}
				if (partial) {
					if (multiple) {
						/* Last partial match. */
						tl->print(tl->user, NL);
						print_token_and_help(tl, partial);
						tl->print(tl->user, NL);
						reprompt = TRUE;
					} else {
						for (i = strlen(word); i < strlen(tl->token_dict[partial->token].tokenstr); i++)
							add_char(tl, tl->token_dict[partial->token].tokenstr[i]);
						add_char(tl, ' ');
					}
				}
			}
		}
	} else {
		/* List all possible tokens from this point. */
		if (!split_line(tl, words, &num_words, TRUE) || !num_words)
			return;
		if (tokenize(tl, words, num_words, &tokens, &arg_needed)) {
			if (arg_needed && arg_needed != T_ARG_TOKEN) {
				tl->print(tl->user, INDENT NL);
				tl->print(tl->user, arg_type_to_string(arg_needed));
				tl->print(tl->user, NL);
				reprompt = TRUE;
			} else if (tokens) {
				tl->print(tl->user, NL);
				for (t = 0; tokens[t].token; t++) {
					print_token_and_help(tl, &tokens[t]);
					tl->print(tl->user, NL);
					reprompt = TRUE;
				}
			}
		}
	}
	unsplit_line(tl);
	if (reprompt) {
		tl->print(tl->user, tl->prompt);
		tl->print(tl->user, tl->buf);
	}
}
コード例 #7
0
ファイル: helper-test.c プロジェクト: blackhole89/rofi
int main ( int argc, char ** argv )
{
    cmd_set_arguments ( argc, argv );

    if ( setlocale ( LC_ALL, "" ) == NULL ) {
        fprintf ( stderr, "Failed to set locale.\n" );
        return EXIT_FAILURE;
    }

    /**
     * Collating.
     */
    char *res = token_collate_key ( "€ Sign", FALSE );
    TASSERT ( strcmp ( res, "€ sign" ) == 0 );
    g_free ( res );

    res = token_collate_key ( "éÉêèë Sign", FALSE );
    TASSERT ( strcmp ( res, "ééêèë sign" ) == 0 );
    g_free ( res );
    res = token_collate_key ( "éÉêèë³ Sign", TRUE );
    TASSERT ( strcmp ( res, "éÉêèë3 Sign" ) == 0 );
    g_free ( res );

    /**
     * Char function
     */

    TASSERT ( helper_parse_char ( "\\n" ) == '\n' );
    TASSERT ( helper_parse_char ( "\\a" ) == '\a' );
    TASSERT ( helper_parse_char ( "\\b" ) == '\b' );
    TASSERT ( helper_parse_char ( "\\t" ) == '\t' );
    TASSERT ( helper_parse_char ( "\\v" ) == '\v' );
    TASSERT ( helper_parse_char ( "\\f" ) == '\f' );
    TASSERT ( helper_parse_char ( "\\r" ) == '\r' );
    TASSERT ( helper_parse_char ( "\\\\" ) == '\\' );
    TASSERT ( helper_parse_char ( "\\0" ) == 0 );
    TASSERT ( helper_parse_char ( "\\x77" ) == 'w' );
    TASSERT ( helper_parse_char ( "\\x0A" ) == '\n' );

    /**
     * tokenize
     */
    config.regex = FALSE;
    config.glob  = FALSE;
    char ** retv = tokenize ( "aAp nOoT MieS 12", FALSE );
    TASSERT ( retv[0] && strcmp ( retv[0], "aap" ) == 0 );
    TASSERT ( retv[1] && strcmp ( retv[1], "noot" ) == 0 );
    TASSERT ( retv[2] && strcmp ( retv[2], "mies" ) == 0 );
    TASSERT ( retv[3] && strcmp ( retv[3], "12" ) == 0 );
    tokenize_free ( retv );
    retv = tokenize ( "blub³ bOb bEp bEE", TRUE );
    TASSERT ( retv[0] && strcmp ( retv[0], "blub3" ) == 0 );
    TASSERT ( retv[1] && strcmp ( retv[1], "bOb" ) == 0 );
    TASSERT ( retv[2] && strcmp ( retv[2], "bEp" ) == 0 );
    TASSERT ( retv[3] && strcmp ( retv[3], "bEE" ) == 0 );
    tokenize_free ( retv );

    TASSERT ( levenshtein ( "aap", "aap" ) == 0 );
    TASSERT ( levenshtein ( "aap", "aap " ) == 1 );
    TASSERT ( levenshtein ( "aap ", "aap" ) == 1 );
    TASSERTE ( levenshtein ( "aap", "aap noot" ), 5 );
    TASSERTE ( levenshtein ( "aap", "noot aap" ), 5 );
    TASSERTE ( levenshtein ( "aap", "noot aap mies" ), 10 );
    TASSERTE ( levenshtein ( "noot aap mies", "aap" ), 10 );
    TASSERTE ( levenshtein ( "otp", "noot aap" ), 5 );
}
コード例 #8
0
ファイル: lex_analyzer.hpp プロジェクト: ArcEye/QGCodeViewer
	LexAnalyzer(std::string line): myLine(line) {
	  tokenize(myLine, tokens);
	}
コード例 #9
0
ファイル: msiformat.cpp プロジェクト: arkose/openbabel
  bool MSIFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv)
  {
    OBMol* pmol = pOb->CastAndClear<OBMol>();
    if(pmol==NULL)
      return false;

    //Define some references so we can use the old parameter names
    istream &ifs = *pConv->GetInStream();
    OBMol &mol = *pmol;
    const char* title = pConv->GetTitle();
    char buffer[BUFF_SIZE];

    stringstream errorMsg;

    if (!ifs)
      return false; // we're attempting to read past the end of the file

    if (!ifs.getline(buffer,BUFF_SIZE))
      {
        obErrorLog.ThrowError(__FUNCTION__,
                              "Problems reading an MSI file: Cannot read the first line.", obWarning);
        return(false);
      }

    if (!EQn(buffer, "# MSI CERIUS2 DataModel File", 28))
      {
        obErrorLog.ThrowError(__FUNCTION__,
                              "Problems reading an MSI file: The first line must contain the MSI header.", obWarning);
        return(false);
      }

    // "records" start with
    // (1 Model
    // ....
    //   and end with
    // ....
    // )
    unsigned int openParens = 0; // the count of "open parentheses" tags
    unsigned int startBondAtom, endBondAtom, bondOrder;
    bool atomRecord = false;
    bool bondRecord = false;
    OBAtom *atom;
//    OBBond *bond;
    vector<string> vs;
    const SpaceGroup *sg;
    bool setSpaceGroup = false;
    double x,y,z;
    vector3 translationVectors[3];
    int numTranslationVectors = 0;

    mol.BeginModify();
    while (ifs.getline(buffer,BUFF_SIZE))
      {
        // model record
        if (strstr(buffer, "Model") != NULL) {
          openParens++;
          continue;
        }

        // atom record
        if (!bondRecord && strstr(buffer, "Atom") != NULL) {
          atomRecord = true;
          openParens++;
          continue;
        }

        if (strstr(buffer, "Bond") != NULL) {
          bondRecord = true;
          startBondAtom = endBondAtom = 0;
          bondOrder = 1;
          openParens++;
          continue;
        }

        /* (A I PeriodicType 100)
           (A D A3 (6.2380000000000004 0 0))
           (A D B3 (0 6.9909999999999997 0))
           (A D C3 (0 0 6.9960000000000004))
           (A C SpaceGroup "63 5")
        */
        if (strstr(buffer, "PeriodicType") != NULL) {
          ifs.getline(buffer,BUFF_SIZE); // next line should be translation vector
          tokenize(vs,buffer);
            while (vs.size() == 6) {
              x = atof((char*)vs[3].erase(0,1).c_str());
              y = atof((char*)vs[4].c_str());
              z = atof((char*)vs[5].c_str());

              translationVectors[numTranslationVectors++].Set(x, y, z);
              if (!ifs.getline(buffer,BUFF_SIZE))
                break;
              tokenize(vs,buffer);
            }
        }

        if (strstr(buffer, "SpaceGroup") != NULL) {
          tokenize(vs, buffer);
          if (vs.size() != 5)
            continue; // invalid space group
          setSpaceGroup = true;
          sg = SpaceGroup::GetSpaceGroup(vs[4]); // remove the initial " character
        }

        // atom information
        if (atomRecord) {
          if (strstr(buffer, "ACL") != NULL) {
            tokenize(vs, buffer);
            // size should be 5 -- need a test here
            if (vs.size() != 5) return false; // timvdm 18/06/2008
            vs[3].erase(0,1); // "6 => remove the first " character
            unsigned int atomicNum = atoi(vs[3].c_str());
            if (atomicNum == 0)
              atomicNum = 1; // hydrogen ?

            // valid element, so create the atom
            atom = mol.NewAtom();
            atom->SetAtomicNum(atomicNum);
            continue;
          }
          else if (strstr(buffer, "XYZ") != NULL) {
            tokenize(vs, buffer);
            // size should be 6 -- need a test here
            if (vs.size() != 6) return false; // timvdm 18/06/2008
            vs[3].erase(0,1); // remove ( character
            vs[5].erase(vs[5].length()-2, 2); // remove trailing )) characters
            atom->SetVector(atof(vs[3].c_str()),
                            atof(vs[4].c_str()),
                            atof(vs[5].c_str()));
            continue;
          }
        } // end of atom records

        // bond information
        if (bondRecord) {
          if (strstr(buffer, "Atom1") != NULL) {
            tokenize(vs, buffer);
            if (vs.size() < 4) return false; // timvdm 18/06/2008
            vs[3].erase(vs[3].length()-1,1);
            startBondAtom = atoi(vs[3].c_str());
            continue;
          }
          else if (strstr(buffer, "Atom2") != NULL) {
            tokenize(vs, buffer);
            if (vs.size() < 4) return false; // timvdm 18/06/2008
            vs[3].erase(vs[3].length()-1,1);
            endBondAtom = atoi(vs[3].c_str());
            continue;
          }
          else if (strstr(buffer, "Type") != NULL) {
            tokenize(vs, buffer);
            if (vs.size() < 4) return false; // timvdm 18/06/2008
            vs[3].erase(vs[3].length()-1,1);
            bondOrder = atoi(vs[3].c_str());
            if (bondOrder == 4) // triple bond?
              bondOrder = 3;
            else if (bondOrder == 8) // aromatic?
              bondOrder = 5;
            else if (bondOrder != 2) // 1 OK, 2 OK, others unknown
              bondOrder = 1;
            continue;
          }
        }

        // ending a "tag" -- a lone ")" on a line
        if (strstr(buffer,")") != NULL && strstr(buffer, "(") == NULL) {
          openParens--;
          if (atomRecord) {
            atomRecord = false;
          }
          if (bondRecord) {
            // Bond records appear to be questionable
            mol.AddBond(startBondAtom - 1, endBondAtom - 1, bondOrder);
            bondRecord = false;
          }

          if (openParens == 0) {
            ifs.getline(buffer, BUFF_SIZE);
            break; // closed this molecule
          }
        }
      }

    mol.EndModify();

    // clean out any remaining blank lines
    while(ifs.peek() != EOF && ifs.good() &&
          (ifs.peek() == '\n' || ifs.peek() == '\r'))
      ifs.getline(buffer,BUFF_SIZE);

    /*
    if (!pConv->IsOption("b",OBConversion::INOPTIONS))
      mol.ConnectTheDots();
    if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
      mol.PerceiveBondOrders();
    */

    if (numTranslationVectors > 0) {
      OBUnitCell* uc = new OBUnitCell;
      uc->SetData(translationVectors[0], translationVectors[1], translationVectors[2]);
      uc->SetOrigin(fileformatInput);
      if (setSpaceGroup) {
        uc->SetSpaceGroup(sg);
      }
      mol.SetData(uc);
    }

    return(true);
  }
コード例 #10
0
ファイル: traffic.cpp プロジェクト: pranamibhatt/booksim
TrafficPattern * TrafficPattern::New(string const & pattern, int nodes)
{
  string pattern_name;
  string param_str;
  size_t left = pattern.find_first_of('(');
  if(left == string::npos) {
    pattern_name = pattern;
  } else {
    pattern_name = pattern.substr(0, left);
    size_t right = pattern.find_last_of(')');
    if(right == string::npos) {
      param_str = pattern.substr(left+1);
    } else {
      param_str = pattern.substr(left+1, right-left-1);
    }
  }
  vector<string> params = tokenize(param_str);
  
  TrafficPattern * result = NULL;
  if(pattern_name == "bitcomp") {
    result = new BitCompTrafficPattern(nodes);
  } else if(pattern_name == "transpose") {
    result = new TransposeTrafficPattern(nodes);
  } else if(pattern_name == "bitrev") {
    result = new BitRevTrafficPattern(nodes);
  } else if(pattern_name == "shuffle") {
    result = new ShuffleTrafficPattern(nodes);
  } else if(pattern_name == "randperm") {
    int perm_seed = params.empty() ? 0 : atoi(params[0].c_str());
    result = new RandomPermutationTrafficPattern(nodes, perm_seed);
  } else if(pattern_name == "uniform") {
    result = new UniformRandomTrafficPattern(nodes);
  } else if(pattern_name == "background") {
    vector<string> excludes_str = tokenize(params[0]);
    vector<int> excludes(excludes_str.size());
    for(size_t i = 0; i < excludes.size(); ++i) {
      excludes[i] = atoi(excludes_str[i].c_str());
    }
    result = new UniformBackgroundTrafficPattern(nodes, excludes);
  } else if(pattern_name == "diagonal") {
    result = new DiagonalTrafficPattern(nodes);
  } else if(pattern_name == "asymmetric") {
    result = new AsymmetricTrafficPattern(nodes);
  } else if(pattern_name == "taper64") {
    result = new Taper64TrafficPattern(nodes);
  } else if(pattern_name == "bad_dragon") {
    if(params.size() < 2) {
      cout << "Error: Missing parameters for dragonfly bad permutation traffic pattern: " << pattern << endl;
      exit(-1);
    }
    int k = atoi(params[0].c_str());
    int n = atoi(params[1].c_str());
    result = new BadPermDFlyTrafficPattern(nodes, k, n);
  } else if((pattern_name == "tornado") || (pattern_name == "neighbor") ||
	    (pattern_name == "badperm_yarc")) {
    if(params.size() < 3) {
      cout << "Error: Missing parameters for digit permutation traffic pattern: " << pattern << endl;
      exit(-1);
    }
    int k = atoi(params[0].c_str());
    int n = atoi(params[1].c_str());
    int xr = atoi(params[2].c_str());
    if(pattern_name == "tornado") {
      result = new TornadoTrafficPattern(nodes, k, n, xr);
    } else if(pattern_name == "neighbor") {
      result = new NeighborTrafficPattern(nodes, k, n, xr);
    } else if(pattern_name == "badperm_yarc") {
      result = new BadPermYarcTrafficPattern(nodes, k, n, xr);
    }
  } else if(pattern_name == "hotspot") {
    if(params.empty()) {
      cout << "Error: Missing parameter for hotspot traffic pattern: " << pattern << endl;
      exit(-1);
    } 
    vector<string> hotspots_str = tokenize(params[0]);
    vector<int> hotspots(hotspots_str.size());
    for(size_t i = 0; i < hotspots.size(); ++i) {
      hotspots[i] = atoi(hotspots_str[i].c_str());
    }
    vector<int> rates(hotspots.size(), 1);
    if(params.size() >= 2) {
      vector<string> rates_str = tokenize(params[1]);
      rates_str.resize(hotspots.size(), rates_str.back());
      for(size_t i = 0; i < rates.size(); ++i) {
	rates[i] = atoi(rates_str[i].c_str());
      }
    }
    result = new HotSpotTrafficPattern(nodes, hotspots, rates);
  } else {
    cout << "Error: Unknown traffic pattern: " << pattern << endl;
    exit(-1);
  }
  return result;
}
コード例 #11
0
ファイル: cddb.c プロジェクト: Requaos/harvey
static int
cddbfilltoc(Toc *t)
{
	int fd;
	int i;
	char *p, *q;
	Biobuf bin;
	Msf *m;
	char *f[10];
	int nf;
	char *id, *categ;
	char gottrack[MTRACK];
	int gottitle;

	fd = dial("tcp!freedb.freedb.org!888", 0, 0, 0);
	if(fd < 0) {
		fprint(2, "cannot dial: %r\n");
		return -1;
	}
	Binit(&bin, fd, OREAD);

	if((p=Brdline(&bin, '\n')) == nil || atoi(p)/100 != 2) {
	died:
		close(fd);
		Bterm(&bin);
		fprint(2, "error talking to server\n");
		if(p) {
			p[Blinelen(&bin)-1] = 0;
			fprint(2, "server says: %s\n", p);
		}
		return -1;
	}

	fprint(fd, "cddb hello gre plan9 9cd 1.0\r\n");
	if((p = Brdline(&bin, '\n')) == nil || atoi(p)/100 != 2)
		goto died;

	fprint(fd, "cddb query %8.8lux %d", diskid(t), t->ntrack);
	DPRINT(2, "cddb query %8.8lux %d", diskid(t), t->ntrack);
	for(i=0; i<t->ntrack; i++) {
		m = &t->track[i].start;
		fprint(fd, " %d", (m->m*60+m->s)*75+m->f);
		DPRINT(2, " %d", (m->m*60+m->s)*75+m->f);
	}
	m = &t->track[t->ntrack-1].end;
	fprint(fd, " %d\r\n", m->m*60+m->s);
	DPRINT(2, " %d\r\n", m->m*60+m->s);

	if((p = Brdline(&bin, '\n')) == nil || atoi(p)/100 != 2)
		goto died;
	p[Blinelen(&bin)-1] = 0;
	DPRINT(2, "cddb: %s\n", p);
	nf = tokenize(p, f, nelem(f));
	if(nf < 1)
		goto died;

	switch(atoi(f[0])) {
	case 200:	/* exact match */
		if(nf < 3)
			goto died;
		categ = f[1];
		id = f[2];
		break;
	case 211:	/* close matches */
		if((p = Brdline(&bin, '\n')) == nil)
			goto died;
		if(p[0] == '.')	/* no close matches? */
			goto died;
		p[Blinelen(&bin)-1] = '\0';

		/* accept first match */
		nf = tokenize(p, f, nelem(f));
		if(nf < 2)
			goto died;
		categ = f[0];
		id = f[1];

		/* snarf rest of buffer */
		while(p[0] != '.') {
			if((p = Brdline(&bin, '\n')) == nil)
				goto died;
			p[Blinelen(&bin)-1] = '\0';
			DPRINT(2, "cddb: %s\n", p);
		}
		break;
	case 202: /* no match */
	default:
		goto died;
	}

	/* fetch results for this cd */
	fprint(fd, "cddb read %s %s\r\n", categ, id);

	memset(gottrack, 0, sizeof(gottrack));
	gottitle = 0;
	do {
		if((p = Brdline(&bin, '\n')) == nil)
			goto died;
		q = p+Blinelen(&bin)-1;
		while(isspace(*q))
			*q-- = 0;
DPRINT(2, "cddb %s\n", p);
		if(strncmp(p, "DTITLE=", 7) == 0) {
			if (gottitle)
				append(&t->title, p + 7);
			else
				t->title = estrdup(p+7);
			gottitle = 1;
		} else if(strncmp(p, "TTITLE", 6) == 0 && isdigit(p[6])) {
			i = atoi(p+6);
			if(i < t->ntrack) {
				p += 6;
				while(isdigit(*p))
					p++;
				if(*p == '=')
					p++;

				if (gottrack[i])
					append(&t->track[i].title, p);
				else
					t->track[i].title = estrdup(p);
				gottrack[i] = 1;
			}
		} 
	} while(*p != '.');

	fprint(fd, "quit\r\n");
	close(fd);
	Bterm(&bin);

	return 0;
}
コード例 #12
0
ファイル: main.cpp プロジェクト: CCJY/coliru
template <typename R, typename F> void tokenize(R const& range, F const& f) {
    tokenize(std::begin(range), std::end(range), f);
}
コード例 #13
0
int main(int argc, const char * argv[]) {
    
    //  Method call to read input.
    //char *code = initialize(argv[1]);
	char *code = NULL;
    
    //  Create pointer to input file.
    FILE* ifp = fopen(argv[1], "r");
    
    //  Return null if file could not be read.
    if (!ifp)
    {
        
        printf("Error: File not found.\n");
        
        exit(1);
        
    }
    
    //  Determine the length of the input file.
    fseek(ifp, 0, SEEK_END);
    int len = (int)ftell(ifp);
    fseek(ifp, 0, SEEK_SET);
    
    //  Dynamically size string.
    code = (char*)calloc(len + 1, sizeof(char));
    char *index = code;
    char c;
    
    //  Continue appending to String until end of character is reached.
    if ( code )
    {
        while ( (c = getc(ifp)) != EOF )
            
            *index++ = c;
        
        *index = '\0';
        
    }
    else
        
        printf("Error: Memory allocation failed.\n");
    
    //    printf("Input Code:\n%s\n\n",head);  //  bug printing
    
    //return head;
    
    //  Method to remove comments.
    char *cleaned = clean(code, len);
    
    //  Method call to parse tokens.
    token *lexemes = tokenize(cleaned);
    
    //  Print to output files.
    print(lexemes);
    
    //  Free allocated memory.
    free(cleaned);
    
    if ( !lexemes )
        
        free(lexemes);
    
    return 0;
    
}
コード例 #14
0
ファイル: ass_override.cpp プロジェクト: Azpidatziak/Aegisub
void AssOverrideTag::ParseParameters(const wxString &text, AssOverrideTagProto::iterator proto_it) {
	Clear();

	// Tokenize text, attempting to find all parameters
	std::vector<wxString> paramList = tokenize(text);
	size_t totalPars = paramList.size();

	int parsFlag = 1 << (totalPars - 1); // Get optional parameters flag
	// vector (i)clip is the second clip proto_ittype in the list
	if ((Name == "\\clip" || Name == "\\iclip") && totalPars != 4) {
		++proto_it;
	}

	unsigned curPar = 0;
	for (size_t n = 0; n < proto_it->params.size(); n++) {
		AssOverrideParamProto *curproto = &proto_it->params[n];

		// Create parameter
		AssOverrideParameter *newparam = new AssOverrideParameter;
		newparam->classification = curproto->classification;
		Params.push_back(newparam);

		// Check if it's optional and not present
		if (!(curproto->optional & parsFlag) || curPar >= totalPars) {
			newparam->omitted = true;
			continue;
		}

		wxString curtok = paramList[curPar++];

		if (curtok.empty()) {
			curPar++;
			continue;
		}

		wxChar firstChar = curtok[0];
		bool auto4 = (firstChar == '!' || firstChar == '$' || firstChar == '%') && curproto->type != VARDATA_BLOCK;
		if (auto4) {
			newparam->Set(curtok);
		}
		else {
			switch (curproto->type) {
				case VARDATA_INT: {
					long temp;
					curtok.ToLong(&temp);
					newparam->Set<int>(temp);
					break;
				}
				case VARDATA_FLOAT: {
					double temp;
					curtok.ToDouble(&temp);
					newparam->Set(temp);
					break;
				}
				case VARDATA_TEXT:
					newparam->Set(curtok);
					break;
				case VARDATA_BOOL: {
					long temp;
					curtok.ToLong(&temp);
					newparam->Set<bool>(temp != 0);
					break;
				}
				case VARDATA_BLOCK: {
					AssDialogueBlockOverride *temp = new AssDialogueBlockOverride(curtok);
					temp->ParseTags();
					newparam->Set(temp);
					break;
				}
				default:
					break;
			}
		}
	}
}
コード例 #15
0
ファイル: ebwt_build.cpp プロジェクト: Bioboy2014/bowtie
/**
 * main function.  Parses command-line arguments.
 */
int bowtie_build(int argc, const char **argv) {
	try {
		// Reset all global state, including getopt state
		opterr = optind = 1;
		resetOptions();

		string infile;
		vector<string> infiles;
		string outfile;

		parseOptions(argc, argv);
		argv0 = argv[0];
		if(showVersion) {
			cout << argv0 << " version " << BOWTIE_VERSION << endl;
			if(sizeof(void*) == 4) {
				cout << "32-bit" << endl;
			} else if(sizeof(void*) == 8) {
				cout << "64-bit" << endl;
			} else {
				cout << "Neither 32- nor 64-bit: sizeof(void*) = " << sizeof(void*) << endl;
			}
			cout << "Built on " << BUILD_HOST << endl;
			cout << BUILD_TIME << endl;
			cout << "Compiler: " << COMPILER_VERSION << endl;
			cout << "Options: " << COMPILER_OPTIONS << endl;
			cout << "Sizeof {int, long, long long, void*, size_t, off_t}: {"
				 << sizeof(int)
				 << ", " << sizeof(long) << ", " << sizeof(long long)
				 << ", " << sizeof(void *) << ", " << sizeof(size_t)
				 << ", " << sizeof(off_t) << "}" << endl;
			return 0;
		}

		// Get input filename
		if(optind >= argc) {
			cerr << "No input sequence or sequence file specified!" << endl;
			printUsage(cerr);
			return 1;
		}
		infile = argv[optind++];

		// Get output filename
		if(optind >= argc) {
			cerr << "No output file specified!" << endl;
			printUsage(cerr);
			return 1;
		}
		outfile = argv[optind++];

		tokenize(infile, ",", infiles);
		if(infiles.size() < 1) {
			cerr << "Tokenized input file list was empty!" << endl;
			printUsage(cerr);
			return 1;
		}

		// Optionally summarize
		if(verbose) {
			cout << "Settings:" << endl
				 << "  Output files: \"" << outfile << ".*.ebwt\"" << endl
				 << "  Line rate: " << lineRate << " (line is " << (1<<lineRate) << " bytes)" << endl
				 << "  Lines per side: " << linesPerSide << " (side is " << ((1<<lineRate)*linesPerSide) << " bytes)" << endl
				 << "  Offset rate: " << offRate << " (one in " << (1<<offRate) << ")" << endl
				 << "  FTable chars: " << ftabChars << endl
				 << "  Strings: " << (packed? "packed" : "unpacked") << endl
				 ;
			if(bmax == 0xffffffff) {
				cout << "  Max bucket size: default" << endl;
			} else {
				cout << "  Max bucket size: " << bmax << endl;
			}
			if(bmaxMultSqrt == 0xffffffff) {
				cout << "  Max bucket size, sqrt multiplier: default" << endl;
			} else {
				cout << "  Max bucket size, sqrt multiplier: " << bmaxMultSqrt << endl;
			}
			if(bmaxDivN == 0xffffffff) {
				cout << "  Max bucket size, len divisor: default" << endl;
			} else {
				cout << "  Max bucket size, len divisor: " << bmaxDivN << endl;
			}
			cout << "  Difference-cover sample period: " << dcv << endl;
			cout << "  Endianness: " << (bigEndian? "big":"little") << endl
				 << "  Actual local endianness: " << (currentlyBigEndian()? "big":"little") << endl
				 << "  Sanity checking: " << (sanityCheck? "enabled":"disabled") << endl;
	#ifdef NDEBUG
			cout << "  Assertions: disabled" << endl;
	#else
			cout << "  Assertions: enabled" << endl;
	#endif
			cout << "  Random seed: " << seed << endl;
			cout << "  Sizeofs: void*:" << sizeof(void*) << ", int:" << sizeof(int) << ", long:" << sizeof(long) << ", size_t:" << sizeof(size_t) << endl;
			cout << "Input files DNA, " << file_format_names[format] << ":" << endl;
			for(size_t i = 0; i < infiles.size(); i++) {
				cout << "  " << infiles[i] << endl;
			}
		}
		// Seed random number generator
		srand(seed);
		{
			Timer timer(cout, "Total time for call to driver() for forward index: ", verbose);
			if(!packed) {
				try {
					driver<String<Dna, Alloc<> > >(infile, infiles, outfile);
				} catch(bad_alloc& e) {
					if(autoMem) {
						cerr << "Switching to a packed string representation." << endl;
						packed = true;
					} else {
						throw e;
					}
				}
			}
			if(packed) {
				driver<String<Dna, Packed<Alloc<> > > >(infile, infiles, outfile);
			}
		}
		if(doubleEbwt) {
			srand(seed);
			Timer timer(cout, "Total time for backward call to driver() for mirror index: ", verbose);
			if(!packed) {
				try {
					driver<String<Dna, Alloc<> > >(infile, infiles, outfile + ".rev", true);
				} catch(bad_alloc& e) {
					if(autoMem) {
						cerr << "Switching to a packed string representation." << endl;
						packed = true;
					} else {
						throw e;
					}
				}
			}
			if(packed) {
				driver<String<Dna, Packed<Alloc<> > > >(infile, infiles, outfile + ".rev", true);
			}
		}
		return 0;
	} catch(std::exception& e) {
		cerr << "Command: ";
		for(int i = 0; i < argc; i++) cerr << argv[i] << " ";
		cerr << endl;
		return 1;
	} catch(int e) {
		if(e != 0) {
			cerr << "Command: ";
			for(int i = 0; i < argc; i++) cerr << argv[i] << " ";
			cerr << endl;
		}
		return e;
	}
}
コード例 #16
0
ファイル: launcher.cpp プロジェクト: svn2github/synergy-plus
static
BOOL CALLBACK
addDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	// only one add dialog at a time!
	static CScreenInfo* info = NULL;

	switch (message) {
	case WM_INITDIALOG: {
		info = (CScreenInfo*)lParam;

		// set title
		CString title;
		if (info->m_screen.empty()) {
			title = getString(IDS_ADD_SCREEN);
		}
		else {
			title = CStringUtil::format(
								getString(IDS_EDIT_SCREEN).c_str(),
								info->m_screen.c_str());
		}
		SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)title.c_str());

		// fill in screen name
		HWND child = getItem(hwnd, IDC_ADD_SCREEN_NAME_EDIT);
		SendMessage(child, WM_SETTEXT, 0, (LPARAM)info->m_screen.c_str());

		// fill in aliases
		CString aliases;
		for (CStringList::const_iterator index = info->m_aliases.begin();
								index != info->m_aliases.end(); ++index) {
			if (!aliases.empty()) {
				aliases += "\r\n";
			}
			aliases += *index;
		}
		child = getItem(hwnd, IDC_ADD_ALIASES_EDIT);
		SendMessage(child, WM_SETTEXT, 0, (LPARAM)aliases.c_str());

		// set options
		CConfig::CScreenOptions::const_iterator index;
		child = getItem(hwnd, IDC_ADD_HD_CAPS_CHECK);
		index = info->m_options.find(kOptionHalfDuplexCapsLock);
		setItemChecked(child, (index != info->m_options.end() &&
											index->second != 0));
		child = getItem(hwnd, IDC_ADD_HD_NUM_CHECK);
		index = info->m_options.find(kOptionHalfDuplexNumLock);
		setItemChecked(child, (index != info->m_options.end() &&
											index->second != 0));
		child = getItem(hwnd, IDC_ADD_HD_SCROLL_CHECK);
		index = info->m_options.find(kOptionHalfDuplexScrollLock);
		setItemChecked(child, (index != info->m_options.end() &&
											index->second != 0));

		// modifier options
		for (UInt32 i = 0; i < sizeof(s_modifiers) /
									sizeof(s_modifiers[0]); ++i) {
			child = getItem(hwnd, s_modifiers[i].m_ctrlID);

			// fill in options
			for (UInt32 j = 0; j < sizeof(s_modifiers) /
										sizeof(s_modifiers[0]); ++j) {
				SendMessage(child, CB_ADDSTRING, 0,
									(LPARAM)s_modifiers[j].m_name);
			}

			// choose current value
			index            = info->m_options.find(s_modifiers[i].m_optionID);
			KeyModifierID id = s_modifiers[i].m_modifierID;
			if (index != info->m_options.end()) {
				id = index->second;
			}
			SendMessage(child, CB_SETCURSEL, id - baseModifier, 0);
		}

		// dead corners
		UInt32 corners = 0;
		index = info->m_options.find(kOptionScreenSwitchCorners);
		if (index != info->m_options.end()) {
			corners = index->second;
		}
		child = getItem(hwnd, IDC_ADD_DC_TOP_LEFT);
		setItemChecked(child, (corners & kTopLeftMask) != 0);
		child = getItem(hwnd, IDC_ADD_DC_TOP_RIGHT);
		setItemChecked(child, (corners & kTopRightMask) != 0);
		child = getItem(hwnd, IDC_ADD_DC_BOTTOM_LEFT);
		setItemChecked(child, (corners & kBottomLeftMask) != 0);
		child = getItem(hwnd, IDC_ADD_DC_BOTTOM_RIGHT);
		setItemChecked(child, (corners & kBottomRightMask) != 0);
		index = info->m_options.find(kOptionScreenSwitchCornerSize);
		SInt32 size = 0;
		if (index != info->m_options.end()) {
			size = index->second;
		}
		char buffer[20];
		sprintf(buffer, "%d", size);
		child = getItem(hwnd, IDC_ADD_DC_SIZE);
		SendMessage(child, WM_SETTEXT, 0, (LPARAM)buffer);

		return TRUE;
	}

	case WM_COMMAND:
		switch (LOWORD(wParam)) {
		case IDOK: {
			CString newName;
			CStringList newAliases;

			// extract name and aliases
			HWND child = getItem(hwnd, IDC_ADD_SCREEN_NAME_EDIT);
			newName = getWindowText(child);
			child = getItem(hwnd, IDC_ADD_ALIASES_EDIT);
			tokenize(newAliases, getWindowText(child));

			// name must be valid
			if (!ARG->m_config.isValidScreenName(newName)) {
				showError(hwnd, CStringUtil::format(
								getString(IDS_INVALID_SCREEN_NAME).c_str(),
								newName.c_str()));
				return TRUE;
			}

			// aliases must be valid
			for (CStringList::const_iterator index = newAliases.begin();
								index != newAliases.end(); ++index) {
				if (!ARG->m_config.isValidScreenName(*index)) {
					showError(hwnd, CStringUtil::format(
								getString(IDS_INVALID_SCREEN_NAME).c_str(),
								index->c_str()));
					return TRUE;
				}
			}

			// new name may not be in the new alias list
			if (isNameInList(newAliases, newName)) {
				showError(hwnd, CStringUtil::format(
								getString(IDS_SCREEN_NAME_IS_ALIAS).c_str(),
								newName.c_str()));
				return TRUE;
			}

			// name must not exist in config but allow same name.  also
			// allow name if it exists in the old alias list but not the
			// new one.
			if (ARG->m_config.isScreen(newName) &&
				!CStringUtil::CaselessCmp::equal(newName, info->m_screen) &&
				!isNameInList(info->m_aliases, newName)) {
				showError(hwnd, CStringUtil::format(
								getString(IDS_DUPLICATE_SCREEN_NAME).c_str(),
								newName.c_str()));
				return TRUE;
			}

			// aliases must not exist in config but allow same aliases and
			// allow an alias to be the old name.
			for (CStringList::const_iterator index = newAliases.begin();
								index != newAliases.end(); ++index) {
				if (ARG->m_config.isScreen(*index) &&
					!CStringUtil::CaselessCmp::equal(*index, info->m_screen) &&
					!isNameInList(info->m_aliases, *index)) {
					showError(hwnd, CStringUtil::format(
								getString(IDS_DUPLICATE_SCREEN_NAME).c_str(),
								index->c_str()));
					return TRUE;
				}
			}

			// dead corner size must be non-negative
			child = getItem(hwnd, IDC_ADD_DC_SIZE);
			CString valueString = getWindowText(child);
			int cornerSize = atoi(valueString.c_str());
			if (cornerSize < 0) {
				showError(hwnd, CStringUtil::format(
									getString(IDS_INVALID_CORNER_SIZE).c_str(),
									valueString.c_str()));
				SetFocus(child);
				return TRUE;
			}

			// save name data
			info->m_screen  = newName;
			info->m_aliases = newAliases;

			// save options
			child = getItem(hwnd, IDC_ADD_HD_CAPS_CHECK);
			if (isItemChecked(child)) {
				info->m_options[kOptionHalfDuplexCapsLock] = 1;
			}
			else {
				info->m_options.erase(kOptionHalfDuplexCapsLock);
			}
			child = getItem(hwnd, IDC_ADD_HD_NUM_CHECK);
			if (isItemChecked(child)) {
				info->m_options[kOptionHalfDuplexNumLock] = 1;
			}
			else {
				info->m_options.erase(kOptionHalfDuplexNumLock);
			}
			child = getItem(hwnd, IDC_ADD_HD_SCROLL_CHECK);
			if (isItemChecked(child)) {
				info->m_options[kOptionHalfDuplexScrollLock] = 1;
			}
			else {
				info->m_options.erase(kOptionHalfDuplexScrollLock);
			}

			// save modifier options
			for (UInt32 i = 0; i < sizeof(s_modifiers) /
										sizeof(s_modifiers[0]); ++i) {
				child            = getItem(hwnd, s_modifiers[i].m_ctrlID);
				KeyModifierID id = static_cast<KeyModifierID>(
									SendMessage(child, CB_GETCURSEL, 0, 0) +
										baseModifier);
				if (id != s_modifiers[i].m_modifierID) {
					info->m_options[s_modifiers[i].m_optionID] = id;
				}
				else {
					info->m_options.erase(s_modifiers[i].m_optionID);
				}
			}

			// save dead corner options
			UInt32 corners = 0;
			if (isItemChecked(getItem(hwnd, IDC_ADD_DC_TOP_LEFT))) {
				corners |= kTopLeftMask;
			}
			if (isItemChecked(getItem(hwnd, IDC_ADD_DC_TOP_RIGHT))) {
				corners |= kTopRightMask;
			}
			if (isItemChecked(getItem(hwnd, IDC_ADD_DC_BOTTOM_LEFT))) {
				corners |= kBottomLeftMask;
			}
			if (isItemChecked(getItem(hwnd, IDC_ADD_DC_BOTTOM_RIGHT))) {
				corners |= kBottomRightMask;
			}
			info->m_options[kOptionScreenSwitchCorners]    = corners;
			info->m_options[kOptionScreenSwitchCornerSize] = cornerSize;

			// success
			EndDialog(hwnd, 1);
			info = NULL;
			return TRUE;
		}

		case IDCANCEL:
			EndDialog(hwnd, 0);
			info = NULL;
			return TRUE;
		}

	default:
		break;
	}

	return FALSE;
}
コード例 #17
0
SWIGEXPORT void JNICALL Java_hu_rilmta_gate_tokenizers_dummyctokenizer_DummyCTokenizerWrapperJNI_tokenize(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jlong jarg4, jlong jarg5, jintArray jarg6, jlong jarg7, jlong jarg8, jintArray jarg9) {
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int arg3 ;
  int *arg4 = (int *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int temp6 ;
  int temp9 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = 0;
  if (jarg1) {
    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
    if (!arg1) return ;
  }
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = *(int **)&jarg4; 
  arg5 = *(int **)&jarg5; 
  {
    if (!jarg6) {
      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
      return ;
    }
    if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
      SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
      return ;
    }
    temp6 = (int)0;
    arg6 = &temp6; 
  }
  arg7 = *(int **)&jarg7; 
  arg8 = *(int **)&jarg8; 
  {
    if (!jarg9) {
      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
      return ;
    }
    if ((*jenv)->GetArrayLength(jenv, jarg9) == 0) {
      SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
      return ;
    }
    temp9 = (int)0;
    arg9 = &temp9; 
  }
  tokenize((char const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    jint jvalue = (jint)temp6;
    (*jenv)->SetIntArrayRegion(jenv, jarg6, 0, 1, &jvalue);
  }
  {
    jint jvalue = (jint)temp9;
    (*jenv)->SetIntArrayRegion(jenv, jarg9, 0, 1, &jvalue);
  }
  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
  
  
}
コード例 #18
0
ファイル: file_dmol.c プロジェクト: Jwonsever/shirleyxas-newt
gint read_dmol_frame(FILE *fp, struct model_pak *model)
{
gint i, num_tokens;
gchar *line, **buff;
struct core_pak *core;

g_assert(fp != NULL);

line = file_read_line(fp);

while (line)
  {
/* read cell vectors */
  if (g_ascii_strncasecmp(line, "$cell", 5) == 0 && model)
    {
    for (i=0 ; i<3 ; i++)
      {
      g_free(line);
      line = file_read_line(fp);
      buff = tokenize(line, &num_tokens);
      if (num_tokens > 2)
        {
        model->latmat[i] = AU2ANG*str_to_float(*(buff));
        model->latmat[i+3] = AU2ANG*str_to_float(*(buff+1));
        model->latmat[i+6] = AU2ANG*str_to_float(*(buff+2));
        }
      g_strfreev(buff);
      }
    model->periodic = 3;
    model->construct_pbc = TRUE;
    }

/* read coordinates */
  if (g_ascii_strncasecmp(line, "$coord", 5) == 0 && model)
    {
    g_free(line);
    line = file_read_line(fp);
    buff = tokenize(line, &num_tokens);
    while (num_tokens > 3)
      {
      if (elem_symbol_test(*buff))
        {
        core = new_core(*buff, model);
        model->cores = g_slist_prepend(model->cores, core);
        core->x[0] = AU2ANG*str_to_float(*(buff+1));
        core->x[1] = AU2ANG*str_to_float(*(buff+2));
        core->x[2] = AU2ANG*str_to_float(*(buff+3));
        }
      g_free(line);
      line = file_read_line(fp);
      g_strfreev(buff);
      buff = tokenize(line, &num_tokens);
      }
    g_strfreev(buff);
    model->fractional = FALSE;
    }

/* terminate frame read */
  if (g_ascii_strncasecmp(line, "$end", 4) == 0)
    return(0);

  g_free(line);
  line = file_read_line(fp);
  }

return(1);
}
コード例 #19
0
ファイル: ThermTrace.cpp プロジェクト: jockey10/sesc
void ThermTrace::read_floorplan_mapping() {

  GI(input_file_[0]!=0,!mapping.empty()); // first call read_sesc_variable

  const char *flpSec = SescConf->getCharPtr("","floorplan");
  size_t min = SescConf->getRecordMin(flpSec,"blockDescr");
  size_t max = SescConf->getRecordMax(flpSec,"blockDescr");

  // Floor plan parameters
  for(size_t id=min;id<=max;id++) {
    if (!SescConf->checkCharPtr(flpSec,"blockDescr", id)) {
      MSG("There is a WHOLE on the floorplan. This can create problems blockDescr[%d]", id);
      exit(-1);
      continue;
    }

    const char *blockDescr = SescConf->getCharPtr(flpSec,"blockDescr", id);
    TokenVectorType descr;
    tokenize(blockDescr, descr);

    FLPUnit *xflp = new FLPUnit(strdup(descr[0]));
    xflp->id   = id;
    xflp->area = atof(descr[1])*atof(descr[2]);

    xflp->x       = atof(descr[3]);
    xflp->y       = atof(descr[4]);
    xflp->delta_x = atof(descr[1]);
    xflp->delta_y = atof(descr[2]);

    const char *blockMatch = SescConf->getCharPtr(flpSec,"blockMatch", id);
    tokenize(blockMatch, xflp->match);

    flp.push_back(xflp);
  }

  // Find mappings between variables and flp

  for(size_t id=0;id<flp.size();id++) {
    for(size_t i=0; i<flp[id]->match.size(); i++) {
      for(size_t j=0; j<mapping.size(); j++) {
	if (grep(mapping[j].name, flp[id]->match[i])) {

#ifdef DEBUG
	  MSG("mapping[%d].map[%d]=%d (%s -> %s)", 
	      j, mapping[j].map.size(), id, flp[id]->match[i], mapping[j].name);
#endif

	  I(id < flp.size());
	  flp[id]->units++;
	  I(j < mapping.size());
	  mapping[j].area += flp[id]->area;
	  mapping[j].map.push_back(id);
	}
      }
    }
  }

  for(size_t i=0;i<mapping.size();i++) {
    for(size_t j=0; j<mapping[i].map.size(); j++) {
      float ratio = flp[mapping[i].map[j]]->area/mapping[i].area;
      mapping[i].ratio.push_back(ratio);
    }
  }

  for(size_t j=0; j<mapping.size(); j++) {
    I(mapping[j].map.size() == mapping[j].ratio.size());
    if (mapping[j].map.empty()) {
      MSG("Error: sesc variable %s [%d] does not update any block", mapping[j].name, j);
      exit(3);
    }
  }
}
コード例 #20
0
ファイル: shell.c プロジェクト: Ras-al-Ghul/cshell
int main(int argc, char *argv[]) {
    //Initialize the shell
    init_shell();

    int numofpipes[MAXCMD];

    //Initialize jobs array
    init_jobsarray();

    //Holds the command
    char wholecommand[MAXNUM];
    char dupwholecommand[MAXNUM];
    char *cmdarr[MAXCMD][MAXOP];	//The rows hold commands separated by ;
    //while the columns hold the command and its options separated by " " or \t
    char *pipecmdarr[MAXCMD][MAXCMD][MAXOP];

    char maincmd[MAXNUM];

    //For prompt
    char username[MAXNUM],sysname[MAXNUM],cwdir[MAXNUM];
    char homedir[MAXNUM];
    getcwd(homedir,MAXNUM);
    char duphomedir[MAXNUM];
    duphomedir[0] = '\0';
    strcat(duphomedir,homedir);

    //For tokenizing
    char *str1 = NULL;
    char *token = NULL;

    //Counters
    int i;

    //Initializing background process array
    for(i=0; i<(MAXNUM*MAXOP); i++) {
        bgrounds[i].used = 0;
    }
    //Initializing ends

    //Initialize to NULL
    initarray(cmdarr);

    char *hdir[MAXNUM];
    //Tokenize home directory
    tokenize(str1,hdir,token,duphomedir);
    //Tokenize home directory done

    while(1) {

        if(signal(SIGINT,signal_handler)==SIG_ERR)
            perror("Signal not caught!!");
        if(signal(SIGCHLD,signal_handler)==SIG_ERR)
            perror("Signal not caught!!");

        for(i=0; i<MAXCMD; i++)
            numofpipes[i] = 0;

        rectifyjobsarray();

        //Printing message on background process completion
        for(i=0; i<(MAXNUM*MAXOP); i++) {
            if(bgrounds[i].used == 0)
                continue;
            bgrounds[i].used = 0;
            if(bgrounds[i].status == 1) {
                //printf("Process %s with pid %d terminated normally\n",bgrounds[i].name,bgrounds[i].pid);
            }
            else {
                //printf("Process %s with pid %d terminated with status %d\n",bgrounds[i].name,bgrounds[i].pid,bgrounds[i].status);
            }
        }

        //Renitializing background process array
        for(i=0; i<(MAXNUM*MAXOP); i++) {
            bgrounds[i].used = 0;
        }
        //Renitializing ends

        //Initialize to NULL
        initarray(cmdarr);
        initpipecmd(pipecmdarr);

        //For prompt
        username[0] = '\0';
        cwdir[0] = '\0';
        strcat(username,getlogin());
        gethostname(sysname,MAXNUM);
        getcwd(cwdir,MAXNUM);
        char dupcwdir[MAXNUM];
        dupcwdir[0] = '\0';
        strcat(dupcwdir,cwdir);

        directorysettings(cwdir,homedir,dupcwdir,hdir);
        //Prompt settings done

        //Take commands
        printf("<%s@%s:%s>",username,sysname,cwdir);
        wholecommand[0] = '\0';
        dupwholecommand[0] = '\0';
        readLine(wholecommand);
        wholecommand[strlen(wholecommand)-1]='\0';
        strcpy(dupwholecommand,wholecommand);
        //Done taking commands

        //Tokenize
        maintokenize(cmdarr,dupwholecommand);
        //tokentest(cmdarr);
        pipetokenize(cmdarr,pipecmdarr,numofpipes);
        //pipetokenizetest(cmdarr,pipecmdarr,numofpipes);
        //exit(EXIT_SUCCESS);
        //continue;
        //Tokenize done


        //Executing each ; separated command
        for(i = 0; i< MAXCMD; i++) {
            if(cmdarr[i][0] == NULL)
                continue;
            maincmd[0] = '\0';
            strcat(maincmd,cmdarr[i][0]);

            strcpy(infile,"\0");
            strcpy(outfile,"\0");


            if(numofpipes[i] != 0) {		//Execute piped commands
                pipesexecute(cmdarr, pipecmdarr, numofpipes, i);
                continue;
            }


            if((strcmp(maincmd,"echo") == 0) || (strcmp(maincmd,"pwd") == 0) || (strcmp(maincmd,"cd") == 0)\
                    || (strcmp(maincmd,"clear") == 0) || (strcmp(maincmd,"quit") == 0) || (strcmp(maincmd,"pinfo") == 0) ||
                    strcmp(maincmd,"jobs") == 0 || strcmp(maincmd,"overkill") == 0 || strcmp(maincmd,"kjob") == 0
                    || strcmp(maincmd,"fg") == 0 ) {

                int dupstdout = dup(1);
                int dupstdin = dup(0);

                if(checkinfile(cmdarr,i) == 1) {

                    if(strcmp(infile,"\0") != 0) {
                        int in=open(infile,O_RDONLY);
                        dup2(in,0);
                        close(in);
                    }
                }

                int outretval = checkoutfile(cmdarr,i);
                if(outretval == 1 || outretval == 2) {

                    if(strcmp(outfile,"\0") != 0) {
                        if(outretval == 1) {
                            int out=open(outfile,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
                            dup2(out,1);
                            close(out);
                        }
                        else {
                            if(fopen(outfile,"r") == NULL) {
                                int out=open(outfile,O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
                                dup2(out,1);
                                close(out);
                            }
                            else {
                                int out=open(outfile,O_WRONLY | O_APPEND, S_IRUSR | S_IRGRP | S_IWGRP | S_IWUSR);
                                dup2(out,1);
                                close(out);
                            }
                        }
                    }
                }


                //echo execution
                if(strcmp (maincmd,"echo") == 0) {
                    exececho(wholecommand,cmdarr,i);
                }
                //echo done

                //pwd execution
                if(strcmp (maincmd,"pwd") == 0) {
                    execpwd();
                }
                //pwd done

                //chdir execution
                if(strcmp (maincmd,"cd") == 0) {
                    execcd(cmdarr,homedir,i);
                }
                //chdir done

                //clear execution
                if(strcmp (maincmd,"clear") == 0) {
                    printf("\e[1;1H\e[2J");
                }
                //clear done

                //terminal quit
                if(strcmp (maincmd,"quit") == 0) {
                    exit(EXIT_SUCCESS);
                }
                //terminal quit done

                //jobs
                if(strcmp (maincmd,"jobs") == 0) {
                    execjobs();
                }
                //jobs done

                //overkill
                if(strcmp (maincmd,"overkill") == 0) {
                    execoverkill();
                }
                //overkill done

                //kjob
                if(strcmp (maincmd,"kjob") == 0) {
                    execkjob(cmdarr,i);
                }
                //kjob done

                //fg
                if(strcmp (maincmd,"fg") == 0) {
                    execfg(cmdarr,i);
                }
                //fg done

                //pinfo
                if(strcmp (maincmd,"pinfo") == 0) {
                    pid_t proid;
                    int flag = 0;
                    if(cmdarr[i][1] == NULL)	//pinfo of shell
                        proid = getpid();
                    else {	//pinfo of given pid
                        char temps[MAXNUM];
                        strcpy(temps,cmdarr[i][1]);
                        proid = atoi(temps);
                        if(kill(proid,0) == (-1)) {
                            printf("No such process exists\n");
                            continue;
                        }
                        flag = 1;
                    }
                    getpinfo(proid, flag, homedir);
                }
                //pinfo done

                dup2(dupstdin,0);
                dup2(dupstdout,1);

            }
            else {
コード例 #21
0
ファイル: ntpdc.c プロジェクト: verm/gsoc-ntp-2013
/*
 * docmd - decode the command line and execute a command
 */
static void
docmd(
	const char *cmdline
	)
{
	char *tokens[1+MAXARGS+MOREARGS+2];
	struct parse pcmd;
	int ntok;
	int i, ti;
	int rval;
	struct xcmd *xcmd;

	ai_fam_templ = ai_fam_default;
	/*
	 * Tokenize the command line.  If nothing on it, return.
	 */
	if (strlen(cmdline) >= MAXLINE) {
		fprintf(stderr, "***Command ignored, more than %d characters:\n%s\n",
			MAXLINE - 1, cmdline);
		return;
	}
	tokenize(cmdline, tokens, &ntok);
	if (ntok == 0)
	    return;
	
	/*
	 * Find the appropriate command description.
	 */
	i = findcmd(tokens[0], builtins, opcmds, &xcmd);
	if (i == 0) {
		(void) fprintf(stderr, "***Command `%s' unknown\n",
			       tokens[0]);
		return;
	} else if (i >= 2) {
		(void) fprintf(stderr, "***Command `%s' ambiguous\n",
			       tokens[0]);
		return;
	}
	
	/*
	 * Save the keyword, then walk through the arguments, interpreting
	 * as we go.
	 */
	pcmd.keyword = tokens[0];
	pcmd.nargs = 0;
	ti = 1;
	for (i = 0; i < MAXARGS && xcmd->arg[i] != NO;) {
		if ((i+ti) >= ntok) {
			if (!(xcmd->arg[i] & OPT)) {
				printusage(xcmd, stderr);
				return;
			}
			break;
		}
		if ((xcmd->arg[i] & OPT) && (*tokens[i+ti] == '>'))
			break;
		rval = getarg(tokens[i+ti], (int)xcmd->arg[i], &pcmd.argval[i]);
		if (rval == -1) {
			ti++;
			continue;
		}
		if (rval == 0)
			return;
		pcmd.nargs++;
		i++;
	}

	/* Any extra args are assumed to be "OPT|NTP_STR". */
	for ( ; i < MAXARGS + MOREARGS;) {
	     if ((i+ti) >= ntok)
		  break;
		rval = getarg(tokens[i+ti], (int)(OPT|NTP_STR), &pcmd.argval[i]);
		if (rval == -1) {
			ti++;
			continue;
		}
		if (rval == 0)
			return;
		pcmd.nargs++;
		i++;
	}

	i += ti;
	if (i < ntok && *tokens[i] == '>') {
		char *fname;

		if (*(tokens[i]+1) != '\0')
		    fname = tokens[i]+1;
		else if ((i+1) < ntok)
		    fname = tokens[i+1];
		else {
			(void) fprintf(stderr, "***No file for redirect\n");
			return;
		}

		current_output = fopen(fname, "w");
		if (current_output == NULL) {
			(void) fprintf(stderr, "***Error opening %s: ", fname);
			perror("");
			return;
		}
	} else {
		current_output = stdout;
	}

	if (interactive && setjmp(interrupt_buf)) {
		return;
	} else {
		jump = 1;
		(xcmd->handler)(&pcmd, current_output);
		jump = 0;
		if (current_output != stdout)
			(void) fclose(current_output);
		current_output = NULL;
	}
}
コード例 #22
0
ファイル: xearthwin.cpp プロジェクト: whztt07/agglobe
bool DoRefresh()
{
    char cmdline[1024];
    sprintf(cmdline, "xearth -bmp");
    strcat(cmdline, Settings.proj ? " -proj merc" : " -proj orth");
    if (Settings.pos.type != Position::_default) {
      strcat(cmdline, " -pos");
      switch (Settings.pos.type) {
        case Position::fixed:
          sprintf(&cmdline[strlen(cmdline)], " fixed,%f,%f", Settings.pos.latitude, Settings.pos.longitude);
          break;
        case Position::sunrel:
          sprintf(&cmdline[strlen(cmdline)], " sunrel,%f,%f", Settings.pos.rlatitude, Settings.pos.rlongitude);
          break;
        case Position::orbit:
          sprintf(&cmdline[strlen(cmdline)], " orbit,%f,%f", Settings.pos.period, Settings.pos.inclination);
          break;
        case Position::random:
          strcat(cmdline, " random");
          break;
      }
    }
    if (Settings.rot != 0) {
      sprintf(&cmdline[strlen(cmdline)], " -rot %f", Settings.rot);
    }
    if (Settings.sunpos.type != Position::_default) {
      strcat(cmdline, " -sunpos");
      switch (Settings.sunpos.type) {
        case Position::fixed:
          sprintf(&cmdline[strlen(cmdline)], " %f,%f", Settings.sunpos.latitude, Settings.sunpos.longitude);
          break;
      }
    }
    if (Settings.mag != 1) {
      sprintf(&cmdline[strlen(cmdline)], " -mag %f", Settings.mag);
    }
    strcat(cmdline, " -size");
    if (Settings.size.cx == 0 || Settings.size.cy == 0) {
      sprintf(&cmdline[strlen(cmdline)], " %d,%d", GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
    } else {
      sprintf(&cmdline[strlen(cmdline)], " %d,%d", Settings.size.cx, Settings.size.cy);
    }
    if (Settings.shift.x != 0 || Settings.shift.y != 0) {
      sprintf(&cmdline[strlen(cmdline)], " -shift %d,%d", Settings.shift.x, Settings.shift.y);
    }
    strcat(cmdline, Settings.shade ? " -shade" : " -noshade");
    strcat(cmdline, Settings.label ? " -label" : " -nolabel");
    if (Settings.label) {
      sprintf(&cmdline[strlen(cmdline)], " -labelpos %d", Settings.labelpos);
    }
    strcat(cmdline, Settings.markers ? " -markers" : " -nomarkers");
    // markerfile
    strcat(cmdline, Settings.stars ? " -stars" : " -nostars");
    if (Settings.stars) {
      sprintf(&cmdline[strlen(cmdline)], " -starfreq %f", Settings.starfreq);
      if (Settings.bigstars > 0) {
        sprintf(&cmdline[strlen(cmdline)], " -bigstars %d", Settings.bigstars);
      }
    }
    strcat(cmdline, Settings.grid ? " -grid" : " -nogrid");
    if (Settings.grid) {
      sprintf(&cmdline[strlen(cmdline)], " -grid1 %d", Settings.grid1);
      sprintf(&cmdline[strlen(cmdline)], " -grid2 %d", Settings.grid2);
    }
    if (Settings.shade) {
      sprintf(&cmdline[strlen(cmdline)], " -day %d", Settings.day);
      sprintf(&cmdline[strlen(cmdline)], " -night %d", Settings.night);
      sprintf(&cmdline[strlen(cmdline)], " -term %d", Settings.term);
    }
    sprintf(&cmdline[strlen(cmdline)], " -gamma %f", Settings.gamma);
    if (Settings.timewarp != 1) {
      sprintf(&cmdline[strlen(cmdline)], " -timewarp %f", Settings.timewarp);
    }
    if (Settings.time) {
      sprintf(&cmdline[strlen(cmdline)], " -time %d", Settings.time);
    }
    int argc;
    char **argv = tokenize(cmdline, &argc);
    int err = setjmp(fataljmp);
    if (err == 0) {
      main(argc, argv);
    } else {
      const char *msg = reinterpret_cast<const char *>(err);
		return false;
	}
    free(argv);
  return true;
}
コード例 #23
0
gint read_nwout_block(FILE *fp, struct model_pak *model)
{
gint num_tokens;
gchar **buff, line[LINELEN], *text;
GString *gstring;
GSList *clist;
struct core_pak *core;

clist = model->cores;
  
/* skip until get a 1 in first column for first coordinate */
if (fgetline(fp, line))
  return(1);
while (g_ascii_strncasecmp(line, "    1", 5) != 0)
  {
  if (fgetline(fp, line))
    return(1);
  }

buff = tokenize(line, &num_tokens);
while (num_tokens > 0)
  {
  if (clist)
    {
    core = clist->data;
    clist = g_slist_next(clist);
    }
  else
    {
    core = new_core(*(buff+1), model);
    model->cores = g_slist_append(model->cores, core);
    }

  core->x[0] = str_to_float(*(buff+3));
  core->x[1] = str_to_float(*(buff+4));
  core->x[2] = str_to_float(*(buff+5));

#if DEBUG_READ_NWOUT
P3VEC("coords: ", core->x);
#endif

/* get next line */
  g_strfreev(buff);
  if (fgetline(fp, line))
    return(2);
  buff = tokenize(line, &num_tokens);
  }

g_strfreev(buff);

/* read until get the details of the current optimisation step */  
while (g_ascii_strncasecmp(line, "@", 1) != 0)
  {
  if (fgetline(fp, line))
    return(0);
  }

buff = tokenize(line, &num_tokens);
while (g_ascii_strncasecmp(line, "@", 1) == 0)
  {
  if (g_ascii_isdigit(buff[1][0]))
    {
    text = format_value_and_units(*(buff+2), 5);
    gstring = g_string_new(text);
    g_free(text);
    g_string_append(gstring, " a.u.");
    property_add_ranked(3, "Energy", gstring->str, model);
    g_string_free(gstring, TRUE);
 
    text = format_value_and_units(*(buff+5), 5);
    gstring = g_string_new(text);
    g_free(text);
    g_string_append(gstring, " a.u./A");
    property_add_ranked(4, "RMS Gradient", gstring->str, model);
    g_string_free(gstring, TRUE);
    }
  /* get next line */
  g_strfreev(buff);
  if (fgetline(fp, line))
    return(2);
  buff = tokenize(line, &num_tokens);
  }

return(0);
}
コード例 #24
0
ファイル: file_xml.c プロジェクト: Bhattiasif/gdis
void xml_parse_atom(const gchar **names, const gchar **values)
{
gint i, n;
gchar **buff;

g_assert(xml_model != NULL);

/* init structure */
if (!xml_core)
  {
  xml_core = new_core("X", xml_model);
  xml_model->cores = g_slist_prepend(xml_model->cores, xml_core);
  }

/* process attributes (if any) */
i=0;
while (*(names+i))
  {
  if (g_ascii_strncasecmp(*(names+i), "elementType\0", 12) == 0)
    {
/* FIXME - potential overflow bug here, since label is an array */
    g_free(xml_core->atom_label);
    xml_core->atom_label = g_strdup(*(values+i));     
    core_init(xml_core->atom_label, xml_core, xml_model);
    }
  if (g_ascii_strncasecmp(*(names+i), "xyzf", 4) == 0)
    {
    buff = tokenize(*(values+i), &n);
    if (n > 2)
      {
      xml_core->x[0] = str_to_float(*(buff+0));
      xml_core->x[1] = str_to_float(*(buff+1));
      xml_core->x[2] = str_to_float(*(buff+2));
      xml_model->fractional = TRUE;
      }
    }
  if (g_ascii_strncasecmp(*(names+i), "xf", 2) == 0)
    {
    xml_core->x[0] = str_to_float(*(values+i));
/* FIXME - inefficient to repeat this for all atoms */
/* but may be necessary if every atom is allowed to be cart or fract */
    xml_model->fractional = TRUE;
    }
  if (g_ascii_strncasecmp(*(names+i), "x3", 2) == 0)
    {
    xml_core->x[0] = str_to_float(*(values+i));
/* FIXME - inefficient to repeat this for all atoms */
/* but may be necessary if every atom is allowed to be cart or fract */
    xml_model->fractional = FALSE;
    }

  if (g_ascii_strncasecmp(*(names+i), "yf", 2) == 0 ||
      g_ascii_strncasecmp(*(names+i), "y3", 2) == 0) 
    {
    xml_core->x[1] = str_to_float(*(values+i));
    }
  if (g_ascii_strncasecmp(*(names+i), "zf", 2) == 0 ||
      g_ascii_strncasecmp(*(names+i), "z3", 2) == 0) 
    {
    xml_core->x[2] = str_to_float(*(values+i));
    }
  i++;
  }
}
コード例 #25
0
ファイル: ofXml.cpp プロジェクト: 8morikazuto/openFrameworks
//---------------------------------------------------------
bool ofXml::setAttribute(const string& path, const string& value)
{
    
    string attributeName, pathToAttribute;
    bool hasPath = false;

    // you can pass either /node[@attr] or just attr
    if(path.find("[@") != string::npos)
    {
        size_t attrBegin = path.find("[@");
        size_t start = attrBegin + 2;
        size_t end = path.find("]", start);
        attributeName = path.substr( start, end - start );
        pathToAttribute = path.substr(0, attrBegin);
        hasPath = true;
    }
    else
    {
        attributeName = path;
    }
    
    // we don't have a path to resolve
    Poco::AutoPtr<Poco::XML::Attr> attr = getPocoDocument()->createAttribute(attributeName);
    attr->setValue(value);
    
    if(!hasPath) {
        Poco::AutoPtr<Poco::XML::NamedNodeMap> map = element->attributes();
        map->setNamedItem(attr);
        return true; // and we're done
    }
    
    // we have a path to resolve
    Poco::XML::Element* curElement = getPocoElement(pathToAttribute);
    
    if(!curElement) { // if it doesn't exist
        
        vector<string> tokens;
        
        if(path.find('/') != string::npos) {
            tokens = tokenize(pathToAttribute, "/");
        }
        
        // is this a tokenized tag?
        if(tokens.size() > 1) 
        {
            // don't 'push' down into the new nodes
            curElement = element;
            
            // find the last existing tag
            size_t lastExistingTag = 0;
            
            // can't use reverse_iterator b/c accumulate doesn't like it
            for(vector<string>::iterator it = tokens.end(); it != tokens.begin(); it--) 
            {
                string empty = "";
                string concat = accumulate(tokens.begin(), it, std::string());
                Poco::XML::Element* testElement = getPocoElement(concat);
                if(testElement) {
                    lastExistingTag++;
                    curElement = testElement;
                    break;
                }
            }
            
            // create all the tags that don't exist
			for(size_t i = lastExistingTag; i < tokens.size(); i++)
            {
                Poco::XML::Element *newElement = getPocoDocument()->createElement(tokens.at(i));
                curElement->appendChild(newElement);
                curElement = newElement;
                
            }
            
            curElement->setAttribute(attributeName, value);
            return true;
        }
        else
        {
            Poco::XML::Element* testElement = getPocoElement(pathToAttribute);
            if(testElement)
            {
                curElement = testElement;
            }
            else
            {
                Poco::XML::Element *newElement = getPocoDocument()->createElement(pathToAttribute);
                curElement->appendChild(newElement);
                curElement = newElement;
            }
            
            curElement->setAttribute(attributeName, value);
            return true;
        }
    }
    return false;
}
コード例 #26
0
ファイル: command.c プロジェクト: Bhattiasif/gdis
void command_main_loop(int argc, char **argv)
{
gint n, status, num_tokens;
gchar *inp, *out, *ext, *tmp, *line, *base, **buff;
gboolean exit=FALSE;
GSList *list, *files, *item, *structures;
struct file_pak *inp_pak, *out_pak;
struct model_pak *model;

if (argc < 2)
  printf("gdis> Commandline interface. Enter ? for help.\n");

/* command line */
do
  {
/* if additional keywords - process as single command line */
  if (argc > 1)
    {
/* convert options into single string for processing */
    buff = g_malloc(argc*sizeof(gchar *));
    for (n=1 ; n<argc ; n++)
      *(buff+n-1) = g_strdup(argv[n]);
    *(buff+argc-1) = NULL;
    line = g_strjoinv(" ", buff);
    g_strfreev(buff);
    exit = TRUE;
    }
  else
    {
/* standard repeating prompt */
    printf("gdis> ");
    line = file_read_line(stdin);
    }

/* quit primitive */
  if (g_ascii_strncasecmp("qu", line, 2) == 0 ||
      g_ascii_strncasecmp("ex", line, 2) == 0)
    exit=TRUE;

/* test primitive */
  if (g_ascii_strncasecmp("te", line, 2) == 0)
    {
    buff = tokenize(line, &num_tokens);
    for (n=1 ; n<num_tokens ; n++)
      test_run(*(buff+n));
    g_strfreev(buff);
    }

/* copy primitive */
  if (g_ascii_strncasecmp("co", line, 2) == 0 || g_ascii_strncasecmp("cp", line, 2) == 0)
    {
    buff = tokenize(line, &num_tokens);

    if (num_tokens > 2)
      {

      out_pak = get_file_info(*(buff+2), BY_EXTENSION);
      if (!out_pak)
        {
        printf("Error: unrecognized output filetype.\n");
        break;
        }
      if (!out_pak->write_file)
        {
        printf("Error: write method for this filetype does not exist.\n");
        break;
        }

/* FIXME! - this is all wrong - should be no dependence on sysenv.cwd for path */
/* since this falls over with something like prompt:>gdis cp /tmp/gok.sot /tmp/dest/gok.meta */
      ext = file_extension_get(*(buff+2));
      files = file_dir_list_pattern(sysenv.cwd, *(buff+1));
      for (list=files ; list ; list=g_slist_next(list))
        {
        inp_pak = get_file_info(list->data, BY_EXTENSION);

        inp = g_build_filename(sysenv.cwd, list->data, NULL);

/* FIXME - changed to correct a problem with Florian's metadata store */
//        base = parse_strip(list->data);
        base = g_strdup(list->data);

        if (inp_pak)
          {
          if (inp_pak->read_file)
            {
            model = model_new();

            status = inp_pak->read_file(inp, model);

            structures = g_slist_find(sysenv.mal, model);

#if DEBUG_COMMAND_MAIN_LOOP
printf("Items loaded = %d [status = %d]\n", g_slist_length(structures), status);
#endif

            if (g_slist_length(structures) > 1)
              {
/* multiple output for input files that contain more than one structure */
              n = 1;
              for (item=structures ; item ; item=g_slist_next(item))
                {
                model = item->data;

                tmp = g_strdup_printf("%s_%d.%s", base, n, ext);
                out = g_build_filename(sysenv.cwd, tmp, NULL);

                status = out_pak->write_file(out, model);

#if DEBUG_COMMAND_MAIN_LOOP
printf("a [%s] -> [%s]\n", inp, out);
#endif
                g_free(out);
                g_free(tmp);
                model_free(model);
                n++;
                }
              }
            else
              {
              tmp = g_strdup_printf("%s.%s", base, ext);

              out = g_build_filename(sysenv.cwd, tmp, NULL);
              g_free(tmp);

              status = out_pak->write_file(out, model);

#if DEBUG_COMMAND_MAIN_LOOP
printf("b [%s] -> [%s]\n", inp, out);
#endif
              g_free(out);
              model_free(model);
              }
            }
          else
            printf("Error: read method for this filetype does not exist.\n");
          }
        else
          {
          printf("Error: unrecognized input filetype.\n");
          }
        g_free(base);
        g_free(inp);
        }


/* CURRENT hack */
if (!files)
  {
/* FIXME */

  }




      g_free(ext);

      free_slist(files);
      }
    else
      printf("Error: insufficient tokens for <copy> command\n");

    g_strfreev(buff);
    }

  if (g_ascii_strncasecmp("ls", line, 2) == 0)
    {
    buff = tokenize(line, &num_tokens);

    if (num_tokens > 1)
      files = file_dir_list_pattern(sysenv.cwd, *(buff+1));
    else
      files = file_dir_list(sysenv.cwd, FALSE);

    for (list=files ; list ; list=g_slist_next(list))
      {
      printf("%s\n", (gchar *) list->data);
      }

    g_strfreev(buff);
    }

  if (g_ascii_strncasecmp("cd", line, 2) == 0)
    {
    buff = tokenize(line, &num_tokens);

    if (num_tokens > 1)
      {
      inp = g_build_path(DIR_SEP, sysenv.cwd, *(buff+1), NULL);
      set_path(inp);
      g_free(inp);
      }

    printf("%s\n", sysenv.cwd);

    g_strfreev(buff);
    }

  if (g_ascii_strncasecmp("pwd", line, 3) == 0)
    {
    printf("%s\n", sysenv.cwd);
    }

  if (g_ascii_strncasecmp("?", line, 1) == 0 || g_ascii_strncasecmp("h", line, 1) == 0)
    {
    printf("GDIS v%4.2f available commands\n\n", VERSION);

    printf("cd <destination>\n");
    printf("    - changes to target directory\n");

    printf("pwd\n");
    printf("    - prints the current working directory\n");

    printf("ls\n");
    printf("    - lists the files in the current working directory\n");

    printf("copy <source> <destination>\n");
    printf("    - convert between filetypes, based on extension (wildcards allowed)\n");
    printf("quit\n");
    printf("    - exit program\n");
    }

/* done -> next line */
  g_free(line);
  }
while (!exit);
}
コード例 #27
0
int main()
{
    char line[MAX_LINE_LENGTH] = { 0 };
    char* lines[MAX_NUM_LINES]; char* words[MAX_NUM_WORDS_PER_LINE] = { 0 };

    /*
     * lines_to_ignore[line_number] is set to true when line is a #define/#undef statement.
     * If we didn't do this, the following line:
     *      #define foo bar
     * would be converted to:
     *      #define bar bar
     * which is clearly not the desired behaviour.
     */
    bool lines_to_ignore[MAX_NUM_LINES] = { 0 };

    int num_lines = 0;

    while (get_line(line) > 0)
    {
        lines[num_lines++] = line;

        int num_words = tokenize(line, words);

        switch (num_words)
        {
            /*
             * This does not (yet) support defines with multiple words
             * following the name of the macro.
             */
            case POSSIBLE_DEFINE:
                lines_to_ignore[num_lines - 1] = handle_possible_define(words);
                break;
            case POSSIBLE_UNDEFINE:
                lines_to_ignore[num_lines - 1] = handle_possible_undefine(words);
                break;
            default:
                break;
        }

        /*
         * For each #defined word for each line, do a strstr for the defined symbol.
         * If a substring is found and the characters before and after the substring aren't:
         *      numeric
         *      alphabetic
         * and we are not:
         *      in a string
         *      in a comment
         *      ignoring this line (because it is the line in which the symbol was defined)
         * then replace the symbol with the replacement text.
         */

        for (int i = 0; i < num_lines; ++i)
        {
            if (lines_to_ignore[i])
            {
                continue;
            }

            for (int j = 0; j < HASH_SIZE; ++j)
            {
                struct list* node = hash_table[j];

                for (; node != NULL; node = node->next)
                {
                    char* start = lines[i];
                    char* occurence = strstr(lines[i], node->name);

                    while (occurence != NULL)
                    {
                        /* Print characters before the occurence. */
                        for (char* c = start; c < occurence; ++c)
                        {
                            putchar(*c);
                        }

                        if (suitable_for_replacement(lines[i], occurence, strlen(node->replacement)))
                        {
                            printf("%s", node->replacement);
                        }
                        else
                        {
                            char* c = occurence;
                            for (; c < occurence + strlen(node->name); ++c)
                            {
                                putchar(*c);
                            }
                            start = c;
                        }

                        
                        occurence = strstr(occurence + strlen(node->name), node->name);
                    }
                }
            }
        }
    }

    return 0;
}
コード例 #28
0
ファイル: tokenizer.c プロジェクト: sidestepism/compiler
token next_tok(tokenizer_t t){
  t = tokenize(t);
  return t->tok;
}
コード例 #29
0
ファイル: parse.cpp プロジェクト: tov/ipd
 Parser::Parser(const string& s) : tokens{tokenize(s)} {}
コード例 #30
0
ファイル: sshare.c プロジェクト: remotesyssupport/openlava
/* parse_group_member()
 */
static link_t *
parse_group_member(const char *gname,
                   uint32_t num,
                   struct group_acct *grps)
{
    link_t *l;
    linkiter_t iter;
    struct group_acct *g;
    int cc;
    char *w;
    char *p;
    uint32_t sum;
    struct share_acct *sacct;

    l = make_link();
    g = NULL;
    for (cc = 0; cc < num; cc++) {

        if (strcmp(gname, grps[cc].group) == 0) {
            g = calloc(1, sizeof(struct group_acct));
            assert(g);
            g->group = strdup(grps[cc].group);
            g->memberList = strdup(grps[cc].memberList);
            g->user_shares = strdup(grps[cc].user_shares);
            tokenize(g->user_shares);
            break;
        }
    }

    /* gudness leaf member
     * caller will free the link
     */
    if (g == NULL)
        return l;

    p = g->memberList;
    sum = 0;
    while ((w = get_next_word(&p))) {

        sacct = get_sacct(w, g->user_shares);
        if (sacct == NULL) {
            while ((sacct = pop_link(l)))
                free_sacct(sacct);
            fin_link(l);
            return NULL;
        }
        sum = sum + sacct->shares;
        enqueue_link(l, sacct);
    }

    traverse_init(l, &iter);
    while ((sacct = traverse_link(&iter))) {
        sacct->dshares = (double)sacct->shares/(double)sum;
    }

    _free_(g->group);
    _free_(g->memberList);
    _free_(g->user_shares);
    _free_(g);

    return l;
}